/*

Copyright (c) 2012 Steven Braeger

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, 
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice 
shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#ifndef GL_PROC_HPP
#define GL_PROC_HPP

#include<string>
#include<sstream>
#include<iterator>

#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)  //if C++0x, then use hash set instead for speed.
#include<unordered_set>
typedef std::unordered_set<std::string> EXTENSION_SET;
#define CONSTRUCT_EXTENSION_SET(x) std::unordered_set<std::string> x(128)
#else
#include<set>
typedef std::set<std::string> EXTENSION_SET;
#define CONSTRUCT_EXTENSION_SET(x) std::set<std::string> x;
#endif


#include<stdexcept>
#include<utility>

#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include<windows.h>
#endif

#ifdef __APPLE__
#include<GL/OpenGL.h>
#else
#include<GL/gl.h>
#endif

//DEFINE PLATFORM GET PROCEDURE CALL

#if defined(__sgi) || defined(__sun) || (defined(__APPLE__) && defined(GLHPP_APPLE_GLX))
#include<dlfcn.h>

typedef void* (*_dl_gpa_func)(const char*);
struct _dl_prim_xpa:
{
	void* h_image;
	_dl_gpa_func x_get_proc_address;
	_dl_prim_xpa():
		h_image(nullptr),
		x_get_proc_address(nullptr)
	{
		h=dlopen(NULL,RTLD_LAZY | RTLD_LOCAL);
		if(h)
		{
			x_get_proc_address=dlsym(h,"glXGetProcAddress");
		}
	}
	void* get(const char* name)
	{
		if(x_get_proc_address)
		{
			return x_get_proc_address(name);
		}
		if(h)
		{
			return dlsym(h,name);
		}
		return nullptr;
	}
};

#elif defined(__APPLE__)

typedef void* (*_dl_gpa_func)(const char*);
struct _dl_prim_xpa:
{
	void* get(const char*)
	{
		return nullptr;
	}
};
#endif

//begin procedure calls.

#if defined(_WIN32)

static inline void* _prim_GetProcAddress(const char* name)
{
	return wglGetProcAddress((LPCSTR)name);
}

#elif defined(__APPLE__)

#include <AvailabilityMacros.h>
#include <mach-o/dyld.h>

#ifdef GLHPP_REGAL
#define GLHPP_APPLE_DYLIB "libRegal.dylib"
#else
#define GLHPP_APPLE_DYLIB "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
#endif

inline void* _apple_dl_get2(const char* name)
{
	static _dl_prim_xpa dxpa;
	return dxpa.get(name);
}

struct _apple_dl_image
{
#ifdef MAC_OS_X_VERSION_10_3
	void* image;
	_apple_dl_image():image(nullptr)
	{
		image=dlopen(GLHPP_APPLE_DYLIB,RTLD_LAZY);
	}
	void* get(const char* name)
	{
		if(!image) 
		{
			return nullptr;
		}
		void* addr=dlsym(image,name);
		if(addr)
		{
			return addr;
		}
		return _apple_dl_get2(name);
	}
#else
	const struct mach_header* image;
	_apple_dl_image():image(nullptr)
	{
		image=NSAddImage(GLHPP_APPLE_DYLIB,NSADDIMAGE_OPTION_RETURN_ON_ERROR);
	}
	static void* get2(const char* name)
	{
		static _dl_prim_xpa dxpa;
		return dxpa.get(name);
	}
	void* get(const char* name)
	{
		std::string symbolname("_");
		symbolname+=name;
		NSSymbol symbol=image ? NSLookupSymbolInImage(image,symbolname.c_str(),NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : nullptr;
		if(symbol)
			return NSAddressOfSymbol(symbol);
		return _apple_dl_get2(name);
	}
#endif	
};

static inline void* _prim_GetProcAddress(const char* name)
{
	static _apple_dl_image adi;
	return adi.get(name);
}
#elif defined(__sun) || defined(__sgi)

static inline void* _prim_GetProcAddress(const char* name)
{
	static _dl_prim_xpa dxpa;
	return dxpa.get(name);
}

#else

extern "C"
{
void *glXGetProcAddressARB(const GLubyte *procName);
}

static inline void* _prim_GetProcAddress(const char* name)
{
	return glXGetProcAddressARB(reinterpret_cast<const GLubyte*>(name));
}

#endif


//define Opengl
namespace gl
{
class ProcedureNotFound: public std::runtime_error
{
public:
	explicit ProcedureNotFound(const std::string& s):
		std::runtime_error(s)
	{}	
};

typedef std::pair<unsigned int,unsigned int> version_info;

bool check_extension(const std::string& extname);
bool check_version(unsigned int vmaj,unsigned int vmin);
bool check_version(const version_info& version);
version_info get_version();
void* get_proc_address(const std::string& funcname);
void* get_proc_address(const std::string& funcname,const std::string& extname);
EXTENSION_SET get_extensions();



namespace _impl
{
inline version_info _get_version()
{
	const char* vs=reinterpret_cast<const char*>(glGetString(GL_VERSION));
	std::istringstream iss(vs);
	unsigned int maj,min;
	iss >> maj;
	iss.ignore();
	iss >> min;
	return std::make_pair(maj,min);
}

typedef const GLubyte* (*PFNGLGETSTRINGIPROC_PRIV)(GLenum name, GLuint index);
inline EXTENSION_SET _get_extensions()
{
	CONSTRUCT_EXTENSION_SET(extlist);
	GLint extmax;
	if(check_version(3,0))
	{
		static PFNGLGETSTRINGIPROC_PRIV gsi=reinterpret_cast<PFNGLGETSTRINGIPROC_PRIV>(_prim_GetProcAddress("glGetStringi"));
		glGetIntegerv(GL_NUM_EXTENSIONS,&extmax);
		for(GLint i=0;i<extmax;i++)
		{
			extlist.insert((const char*)gsi(GL_EXTENSIONS,i));
		}
	}
	else
	{
		std::istringstream extstream((const char*)glGetString(GL_EXTENSIONS));
		extlist.insert(std::istream_iterator<std::string>(extstream),std::istream_iterator<std::string>());
	}
	
	return extlist;
}

inline void* _get_proc_address(const char* frequest,const char* extext)
{
	if(check_extension(extext))
	{
		void* fptr=_prim_GetProcAddress(frequest);
		if(fptr)
			return fptr;
		else
		{
			std::ostringstream oss;
			oss << "Error, " << extext << " is supported, but " << frequest << " was not found in the context.";
			throw ProcedureNotFound(oss.str());
		}
	}
	else
	{	
		std::ostringstream oss;
		oss << "Error, " << extext << " is not supported, so " << frequest << " was not found in the context.";
		throw ProcedureNotFound(oss.str());
	}
}
inline void* _get_proc_address(const char* frequest,unsigned int vmaj,unsigned int vmin)
{
	if(check_version(vmaj,vmin))
	{
		void* fptr=_prim_GetProcAddress(frequest);
		if(fptr)
			return fptr;
		else
		{
			std::ostringstream oss;
			oss << "Error, OpenGL Version " << vmaj << '.' << vmin << " is supported, but " << frequest << " was not found in the context.  Could this function be deprecated in this context?";
			throw ProcedureNotFound(oss.str());
		}
	}
	else
	{
		std::ostringstream oss;
		oss << "Error, OpenGL Version " << vmaj << '.' << vmin << " is not supported, so " << frequest << " could not be found in the context.";
		throw ProcedureNotFound(oss.str());
	}
}
}

inline bool check_extension(const std::string& extname)
{
	static EXTENSION_SET extarray=_impl::_get_extensions();
	return extarray.find(extname)!=extarray.end();
}

inline version_info get_version()
{
	static version_info v=_impl::_get_version();
	return v;
}
inline bool check_version(unsigned int vmaj,unsigned int vmin)
{
	version_info v=get_version();
	return (vmaj*10+vmin) <= (v.first*10+v.second);
}
inline bool check_version(const version_info& v)
{
	return check_version(v.first,v.second);
}
//TODO: implement these
//inline void* get_proc_address(const std::string& funcname);
//void* get_proc_address(const std::string& funcname,const std::string& extname);
//EXTENSION_SET get_extensions();

#ifndef GLPROC_VERSION
#define GLPROC_VERSION 43
#endif

#if (GLPROC_VERSION >= 10)

#ifndef GL_VERSION_1_0

#define GL_VERSION_1_0

#endif //GL_VERSION_1_0


typedef void (*PFNCULLFACEPROC_HPP)(GLenum mode);

inline void CullFace(GLenum mode)
{
	 glCullFace(mode);
}

typedef void (*PFNFRONTFACEPROC_HPP)(GLenum mode);

inline void FrontFace(GLenum mode)
{
	 glFrontFace(mode);
}

typedef void (*PFNHINTPROC_HPP)(GLenum target,GLenum mode);

inline void Hint(GLenum target,GLenum mode)
{
	 glHint(target,mode);
}

typedef void (*PFNLINEWIDTHPROC_HPP)(GLfloat width);

inline void LineWidth(GLfloat width)
{
	 glLineWidth(width);
}

typedef void (*PFNPOINTSIZEPROC_HPP)(GLfloat size);

inline void PointSize(GLfloat size)
{
	 glPointSize(size);
}

typedef void (*PFNPOLYGONMODEPROC_HPP)(GLenum face,GLenum mode);

inline void PolygonMode(GLenum face,GLenum mode)
{
	 glPolygonMode(face,mode);
}

typedef void (*PFNSCISSORPROC_HPP)(GLint x,GLint y,GLsizei width,GLsizei height);

inline void Scissor(GLint x,GLint y,GLsizei width,GLsizei height)
{
	 glScissor(x,y,width,height);
}

typedef void (*PFNTEXPARAMETERFPROC_HPP)(GLenum target,GLenum pname,GLfloat param);

inline void TexParameterf(GLenum target,GLenum pname,GLfloat param)
{
	 glTexParameterf(target,pname,param);
}

typedef void (*PFNTEXPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

inline void TexParameterfv(GLenum target,GLenum pname,const GLfloat *params)
{
	 glTexParameterfv(target,pname,params);
}

typedef void (*PFNTEXPARAMETERIPROC_HPP)(GLenum target,GLenum pname,GLint param);

inline void TexParameteri(GLenum target,GLenum pname,GLint param)
{
	 glTexParameteri(target,pname,param);
}

typedef void (*PFNTEXPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

inline void TexParameteriv(GLenum target,GLenum pname,const GLint *params)
{
	 glTexParameteriv(target,pname,params);
}

typedef void (*PFNTEXIMAGE1DPROC_HPP)(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

inline void TexImage1D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	 glTexImage1D(target,level,internalformat,width,border,format,type,pixels);
}

typedef void (*PFNTEXIMAGE2DPROC_HPP)(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

inline void TexImage2D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	 glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels);
}

typedef void (*PFNDRAWBUFFERPROC_HPP)(GLenum mode);

inline void DrawBuffer(GLenum mode)
{
	 glDrawBuffer(mode);
}

typedef void (*PFNCLEARPROC_HPP)(GLbitfield mask);

inline void Clear(GLbitfield mask)
{
	 glClear(mask);
}

typedef void (*PFNCLEARCOLORPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);

inline void ClearColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)
{
	 glClearColor(red,green,blue,alpha);
}

typedef void (*PFNCLEARSTENCILPROC_HPP)(GLint s);

inline void ClearStencil(GLint s)
{
	 glClearStencil(s);
}

typedef void (*PFNCLEARDEPTHPROC_HPP)(GLdouble depth);

inline void ClearDepth(GLdouble depth)
{
	 glClearDepth(depth);
}

typedef void (*PFNSTENCILMASKPROC_HPP)(GLuint mask);

inline void StencilMask(GLuint mask)
{
	 glStencilMask(mask);
}

typedef void (*PFNCOLORMASKPROC_HPP)(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha);

inline void ColorMask(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)
{
	 glColorMask(red,green,blue,alpha);
}

typedef void (*PFNDEPTHMASKPROC_HPP)(GLboolean flag);

inline void DepthMask(GLboolean flag)
{
	 glDepthMask(flag);
}

typedef void (*PFNDISABLEPROC_HPP)(GLenum cap);

inline void Disable(GLenum cap)
{
	 glDisable(cap);
}

typedef void (*PFNENABLEPROC_HPP)(GLenum cap);

inline void Enable(GLenum cap)
{
	 glEnable(cap);
}

typedef void (*PFNFINISHPROC_HPP)();

inline void Finish()
{
	 glFinish();
}

typedef void (*PFNFLUSHPROC_HPP)();

inline void Flush()
{
	 glFlush();
}

typedef void (*PFNBLENDFUNCPROC_HPP)(GLenum sfactor,GLenum dfactor);

inline void BlendFunc(GLenum sfactor,GLenum dfactor)
{
	 glBlendFunc(sfactor,dfactor);
}

typedef void (*PFNLOGICOPPROC_HPP)(GLenum opcode);

inline void LogicOp(GLenum opcode)
{
	 glLogicOp(opcode);
}

typedef void (*PFNSTENCILFUNCPROC_HPP)(GLenum func,GLint ref,GLuint mask);

inline void StencilFunc(GLenum func,GLint ref,GLuint mask)
{
	 glStencilFunc(func,ref,mask);
}

typedef void (*PFNSTENCILOPPROC_HPP)(GLenum fail,GLenum zfail,GLenum zpass);

inline void StencilOp(GLenum fail,GLenum zfail,GLenum zpass)
{
	 glStencilOp(fail,zfail,zpass);
}

typedef void (*PFNDEPTHFUNCPROC_HPP)(GLenum func);

inline void DepthFunc(GLenum func)
{
	 glDepthFunc(func);
}

typedef void (*PFNPIXELSTOREFPROC_HPP)(GLenum pname,GLfloat param);

inline void PixelStoref(GLenum pname,GLfloat param)
{
	 glPixelStoref(pname,param);
}

typedef void (*PFNPIXELSTOREIPROC_HPP)(GLenum pname,GLint param);

inline void PixelStorei(GLenum pname,GLint param)
{
	 glPixelStorei(pname,param);
}

typedef void (*PFNREADBUFFERPROC_HPP)(GLenum mode);

inline void ReadBuffer(GLenum mode)
{
	 glReadBuffer(mode);
}

typedef void (*PFNREADPIXELSPROC_HPP)(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid *pixels);

inline void ReadPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLvoid *pixels)
{
	 glReadPixels(x,y,width,height,format,type,pixels);
}

typedef void (*PFNGETBOOLEANVPROC_HPP)(GLenum pname,GLboolean *params);

inline void GetBooleanv(GLenum pname,GLboolean *params)
{
	 glGetBooleanv(pname,params);
}

typedef void (*PFNGETDOUBLEVPROC_HPP)(GLenum pname,GLdouble *params);

inline void GetDoublev(GLenum pname,GLdouble *params)
{
	 glGetDoublev(pname,params);
}

typedef GLenum (*PFNGETERRORPROC_HPP)();

inline GLenum GetError()
{
	return glGetError();
}

typedef void (*PFNGETFLOATVPROC_HPP)(GLenum pname,GLfloat *params);

inline void GetFloatv(GLenum pname,GLfloat *params)
{
	 glGetFloatv(pname,params);
}

typedef void (*PFNGETINTEGERVPROC_HPP)(GLenum pname,GLint *params);

inline void GetIntegerv(GLenum pname,GLint *params)
{
	 glGetIntegerv(pname,params);
}

typedef const GLubyte * (*PFNGETSTRINGPROC_HPP)(GLenum name);

inline const GLubyte * GetString(GLenum name)
{
	return glGetString(name);
}

typedef void (*PFNGETTEXIMAGEPROC_HPP)(GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels);

inline void GetTexImage(GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels)
{
	 glGetTexImage(target,level,format,type,pixels);
}

typedef void (*PFNGETTEXPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

inline void GetTexParameterfv(GLenum target,GLenum pname,GLfloat *params)
{
	 glGetTexParameterfv(target,pname,params);
}

typedef void (*PFNGETTEXPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

inline void GetTexParameteriv(GLenum target,GLenum pname,GLint *params)
{
	 glGetTexParameteriv(target,pname,params);
}

typedef void (*PFNGETTEXLEVELPARAMETERFVPROC_HPP)(GLenum target,GLint level,GLenum pname,GLfloat *params);

inline void GetTexLevelParameterfv(GLenum target,GLint level,GLenum pname,GLfloat *params)
{
	 glGetTexLevelParameterfv(target,level,pname,params);
}

typedef void (*PFNGETTEXLEVELPARAMETERIVPROC_HPP)(GLenum target,GLint level,GLenum pname,GLint *params);

inline void GetTexLevelParameteriv(GLenum target,GLint level,GLenum pname,GLint *params)
{
	 glGetTexLevelParameteriv(target,level,pname,params);
}

typedef GLboolean (*PFNISENABLEDPROC_HPP)(GLenum cap);

inline GLboolean IsEnabled(GLenum cap)
{
	return glIsEnabled(cap);
}

typedef void (*PFNDEPTHRANGEPROC_HPP)(GLdouble near,GLdouble far);

inline void DepthRange(GLdouble near,GLdouble far)
{
	 glDepthRange(near,far);
}

typedef void (*PFNVIEWPORTPROC_HPP)(GLint x,GLint y,GLsizei width,GLsizei height);

inline void Viewport(GLint x,GLint y,GLsizei width,GLsizei height)
{
	 glViewport(x,y,width,height);
}

typedef void (*PFNNEWLISTPROC_HPP)(GLuint list,GLenum mode);

inline void NewList(GLuint list,GLenum mode)
{
	 glNewList(list,mode);
}

typedef void (*PFNENDLISTPROC_HPP)();

inline void EndList()
{
	 glEndList();
}

typedef void (*PFNCALLLISTPROC_HPP)(GLuint list);

inline void CallList(GLuint list)
{
	 glCallList(list);
}

typedef void (*PFNCALLLISTSPROC_HPP)(GLsizei n,GLenum type,const GLvoid *lists);

inline void CallLists(GLsizei n,GLenum type,const GLvoid *lists)
{
	 glCallLists(n,type,lists);
}

typedef void (*PFNDELETELISTSPROC_HPP)(GLuint list,GLsizei range);

inline void DeleteLists(GLuint list,GLsizei range)
{
	 glDeleteLists(list,range);
}

typedef GLuint (*PFNGENLISTSPROC_HPP)(GLsizei range);

inline GLuint GenLists(GLsizei range)
{
	return glGenLists(range);
}

typedef void (*PFNLISTBASEPROC_HPP)(GLuint base);

inline void ListBase(GLuint base)
{
	 glListBase(base);
}

typedef void (*PFNBEGINPROC_HPP)(GLenum mode);

inline void Begin(GLenum mode)
{
	 glBegin(mode);
}

typedef void (*PFNBITMAPPROC_HPP)(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte *bitmap);

inline void Bitmap(GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte *bitmap)
{
	 glBitmap(width,height,xorig,yorig,xmove,ymove,bitmap);
}

typedef void (*PFNCOLOR3BPROC_HPP)(GLbyte red,GLbyte green,GLbyte blue);

inline void Color3b(GLbyte red,GLbyte green,GLbyte blue)
{
	 glColor3b(red,green,blue);
}

typedef void (*PFNCOLOR3BVPROC_HPP)(const GLbyte *v);

inline void Color3bv(const GLbyte *v)
{
	 glColor3bv(v);
}

typedef void (*PFNCOLOR3DPROC_HPP)(GLdouble red,GLdouble green,GLdouble blue);

inline void Color3d(GLdouble red,GLdouble green,GLdouble blue)
{
	 glColor3d(red,green,blue);
}

typedef void (*PFNCOLOR3DVPROC_HPP)(const GLdouble *v);

inline void Color3dv(const GLdouble *v)
{
	 glColor3dv(v);
}

typedef void (*PFNCOLOR3FPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue);

inline void Color3f(GLfloat red,GLfloat green,GLfloat blue)
{
	 glColor3f(red,green,blue);
}

typedef void (*PFNCOLOR3FVPROC_HPP)(const GLfloat *v);

inline void Color3fv(const GLfloat *v)
{
	 glColor3fv(v);
}

typedef void (*PFNCOLOR3IPROC_HPP)(GLint red,GLint green,GLint blue);

inline void Color3i(GLint red,GLint green,GLint blue)
{
	 glColor3i(red,green,blue);
}

typedef void (*PFNCOLOR3IVPROC_HPP)(const GLint *v);

inline void Color3iv(const GLint *v)
{
	 glColor3iv(v);
}

typedef void (*PFNCOLOR3SPROC_HPP)(GLshort red,GLshort green,GLshort blue);

inline void Color3s(GLshort red,GLshort green,GLshort blue)
{
	 glColor3s(red,green,blue);
}

typedef void (*PFNCOLOR3SVPROC_HPP)(const GLshort *v);

inline void Color3sv(const GLshort *v)
{
	 glColor3sv(v);
}

typedef void (*PFNCOLOR3UBPROC_HPP)(GLubyte red,GLubyte green,GLubyte blue);

inline void Color3ub(GLubyte red,GLubyte green,GLubyte blue)
{
	 glColor3ub(red,green,blue);
}

typedef void (*PFNCOLOR3UBVPROC_HPP)(const GLubyte *v);

inline void Color3ubv(const GLubyte *v)
{
	 glColor3ubv(v);
}

typedef void (*PFNCOLOR3UIPROC_HPP)(GLuint red,GLuint green,GLuint blue);

inline void Color3ui(GLuint red,GLuint green,GLuint blue)
{
	 glColor3ui(red,green,blue);
}

typedef void (*PFNCOLOR3UIVPROC_HPP)(const GLuint *v);

inline void Color3uiv(const GLuint *v)
{
	 glColor3uiv(v);
}

typedef void (*PFNCOLOR3USPROC_HPP)(GLushort red,GLushort green,GLushort blue);

inline void Color3us(GLushort red,GLushort green,GLushort blue)
{
	 glColor3us(red,green,blue);
}

typedef void (*PFNCOLOR3USVPROC_HPP)(const GLushort *v);

inline void Color3usv(const GLushort *v)
{
	 glColor3usv(v);
}

typedef void (*PFNCOLOR4BPROC_HPP)(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha);

inline void Color4b(GLbyte red,GLbyte green,GLbyte blue,GLbyte alpha)
{
	 glColor4b(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4BVPROC_HPP)(const GLbyte *v);

inline void Color4bv(const GLbyte *v)
{
	 glColor4bv(v);
}

typedef void (*PFNCOLOR4DPROC_HPP)(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha);

inline void Color4d(GLdouble red,GLdouble green,GLdouble blue,GLdouble alpha)
{
	 glColor4d(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4DVPROC_HPP)(const GLdouble *v);

inline void Color4dv(const GLdouble *v)
{
	 glColor4dv(v);
}

typedef void (*PFNCOLOR4FPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);

inline void Color4f(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)
{
	 glColor4f(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4FVPROC_HPP)(const GLfloat *v);

inline void Color4fv(const GLfloat *v)
{
	 glColor4fv(v);
}

typedef void (*PFNCOLOR4IPROC_HPP)(GLint red,GLint green,GLint blue,GLint alpha);

inline void Color4i(GLint red,GLint green,GLint blue,GLint alpha)
{
	 glColor4i(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4IVPROC_HPP)(const GLint *v);

inline void Color4iv(const GLint *v)
{
	 glColor4iv(v);
}

typedef void (*PFNCOLOR4SPROC_HPP)(GLshort red,GLshort green,GLshort blue,GLshort alpha);

inline void Color4s(GLshort red,GLshort green,GLshort blue,GLshort alpha)
{
	 glColor4s(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4SVPROC_HPP)(const GLshort *v);

inline void Color4sv(const GLshort *v)
{
	 glColor4sv(v);
}

typedef void (*PFNCOLOR4UBPROC_HPP)(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha);

inline void Color4ub(GLubyte red,GLubyte green,GLubyte blue,GLubyte alpha)
{
	 glColor4ub(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4UBVPROC_HPP)(const GLubyte *v);

inline void Color4ubv(const GLubyte *v)
{
	 glColor4ubv(v);
}

typedef void (*PFNCOLOR4UIPROC_HPP)(GLuint red,GLuint green,GLuint blue,GLuint alpha);

inline void Color4ui(GLuint red,GLuint green,GLuint blue,GLuint alpha)
{
	 glColor4ui(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4UIVPROC_HPP)(const GLuint *v);

inline void Color4uiv(const GLuint *v)
{
	 glColor4uiv(v);
}

typedef void (*PFNCOLOR4USPROC_HPP)(GLushort red,GLushort green,GLushort blue,GLushort alpha);

inline void Color4us(GLushort red,GLushort green,GLushort blue,GLushort alpha)
{
	 glColor4us(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4USVPROC_HPP)(const GLushort *v);

inline void Color4usv(const GLushort *v)
{
	 glColor4usv(v);
}

typedef void (*PFNEDGEFLAGPROC_HPP)(GLboolean flag);

inline void EdgeFlag(GLboolean flag)
{
	 glEdgeFlag(flag);
}

typedef void (*PFNEDGEFLAGVPROC_HPP)(const GLboolean *flag);

inline void EdgeFlagv(const GLboolean *flag)
{
	 glEdgeFlagv(flag);
}

typedef void (*PFNENDPROC_HPP)();

inline void End()
{
	 glEnd();
}

typedef void (*PFNINDEXDPROC_HPP)(GLdouble c);

inline void Indexd(GLdouble c)
{
	 glIndexd(c);
}

typedef void (*PFNINDEXDVPROC_HPP)(const GLdouble *c);

inline void Indexdv(const GLdouble *c)
{
	 glIndexdv(c);
}

typedef void (*PFNINDEXFPROC_HPP)(GLfloat c);

inline void Indexf(GLfloat c)
{
	 glIndexf(c);
}

typedef void (*PFNINDEXFVPROC_HPP)(const GLfloat *c);

inline void Indexfv(const GLfloat *c)
{
	 glIndexfv(c);
}

typedef void (*PFNINDEXIPROC_HPP)(GLint c);

inline void Indexi(GLint c)
{
	 glIndexi(c);
}

typedef void (*PFNINDEXIVPROC_HPP)(const GLint *c);

inline void Indexiv(const GLint *c)
{
	 glIndexiv(c);
}

typedef void (*PFNINDEXSPROC_HPP)(GLshort c);

inline void Indexs(GLshort c)
{
	 glIndexs(c);
}

typedef void (*PFNINDEXSVPROC_HPP)(const GLshort *c);

inline void Indexsv(const GLshort *c)
{
	 glIndexsv(c);
}

typedef void (*PFNNORMAL3BPROC_HPP)(GLbyte nx,GLbyte ny,GLbyte nz);

inline void Normal3b(GLbyte nx,GLbyte ny,GLbyte nz)
{
	 glNormal3b(nx,ny,nz);
}

typedef void (*PFNNORMAL3BVPROC_HPP)(const GLbyte *v);

inline void Normal3bv(const GLbyte *v)
{
	 glNormal3bv(v);
}

typedef void (*PFNNORMAL3DPROC_HPP)(GLdouble nx,GLdouble ny,GLdouble nz);

inline void Normal3d(GLdouble nx,GLdouble ny,GLdouble nz)
{
	 glNormal3d(nx,ny,nz);
}

typedef void (*PFNNORMAL3DVPROC_HPP)(const GLdouble *v);

inline void Normal3dv(const GLdouble *v)
{
	 glNormal3dv(v);
}

typedef void (*PFNNORMAL3FPROC_HPP)(GLfloat nx,GLfloat ny,GLfloat nz);

inline void Normal3f(GLfloat nx,GLfloat ny,GLfloat nz)
{
	 glNormal3f(nx,ny,nz);
}

typedef void (*PFNNORMAL3FVPROC_HPP)(const GLfloat *v);

inline void Normal3fv(const GLfloat *v)
{
	 glNormal3fv(v);
}

typedef void (*PFNNORMAL3IPROC_HPP)(GLint nx,GLint ny,GLint nz);

inline void Normal3i(GLint nx,GLint ny,GLint nz)
{
	 glNormal3i(nx,ny,nz);
}

typedef void (*PFNNORMAL3IVPROC_HPP)(const GLint *v);

inline void Normal3iv(const GLint *v)
{
	 glNormal3iv(v);
}

typedef void (*PFNNORMAL3SPROC_HPP)(GLshort nx,GLshort ny,GLshort nz);

inline void Normal3s(GLshort nx,GLshort ny,GLshort nz)
{
	 glNormal3s(nx,ny,nz);
}

typedef void (*PFNNORMAL3SVPROC_HPP)(const GLshort *v);

inline void Normal3sv(const GLshort *v)
{
	 glNormal3sv(v);
}

typedef void (*PFNRASTERPOS2DPROC_HPP)(GLdouble x,GLdouble y);

inline void RasterPos2d(GLdouble x,GLdouble y)
{
	 glRasterPos2d(x,y);
}

typedef void (*PFNRASTERPOS2DVPROC_HPP)(const GLdouble *v);

inline void RasterPos2dv(const GLdouble *v)
{
	 glRasterPos2dv(v);
}

typedef void (*PFNRASTERPOS2FPROC_HPP)(GLfloat x,GLfloat y);

inline void RasterPos2f(GLfloat x,GLfloat y)
{
	 glRasterPos2f(x,y);
}

typedef void (*PFNRASTERPOS2FVPROC_HPP)(const GLfloat *v);

inline void RasterPos2fv(const GLfloat *v)
{
	 glRasterPos2fv(v);
}

typedef void (*PFNRASTERPOS2IPROC_HPP)(GLint x,GLint y);

inline void RasterPos2i(GLint x,GLint y)
{
	 glRasterPos2i(x,y);
}

typedef void (*PFNRASTERPOS2IVPROC_HPP)(const GLint *v);

inline void RasterPos2iv(const GLint *v)
{
	 glRasterPos2iv(v);
}

typedef void (*PFNRASTERPOS2SPROC_HPP)(GLshort x,GLshort y);

inline void RasterPos2s(GLshort x,GLshort y)
{
	 glRasterPos2s(x,y);
}

typedef void (*PFNRASTERPOS2SVPROC_HPP)(const GLshort *v);

inline void RasterPos2sv(const GLshort *v)
{
	 glRasterPos2sv(v);
}

typedef void (*PFNRASTERPOS3DPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

inline void RasterPos3d(GLdouble x,GLdouble y,GLdouble z)
{
	 glRasterPos3d(x,y,z);
}

typedef void (*PFNRASTERPOS3DVPROC_HPP)(const GLdouble *v);

inline void RasterPos3dv(const GLdouble *v)
{
	 glRasterPos3dv(v);
}

typedef void (*PFNRASTERPOS3FPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

inline void RasterPos3f(GLfloat x,GLfloat y,GLfloat z)
{
	 glRasterPos3f(x,y,z);
}

typedef void (*PFNRASTERPOS3FVPROC_HPP)(const GLfloat *v);

inline void RasterPos3fv(const GLfloat *v)
{
	 glRasterPos3fv(v);
}

typedef void (*PFNRASTERPOS3IPROC_HPP)(GLint x,GLint y,GLint z);

inline void RasterPos3i(GLint x,GLint y,GLint z)
{
	 glRasterPos3i(x,y,z);
}

typedef void (*PFNRASTERPOS3IVPROC_HPP)(const GLint *v);

inline void RasterPos3iv(const GLint *v)
{
	 glRasterPos3iv(v);
}

typedef void (*PFNRASTERPOS3SPROC_HPP)(GLshort x,GLshort y,GLshort z);

inline void RasterPos3s(GLshort x,GLshort y,GLshort z)
{
	 glRasterPos3s(x,y,z);
}

typedef void (*PFNRASTERPOS3SVPROC_HPP)(const GLshort *v);

inline void RasterPos3sv(const GLshort *v)
{
	 glRasterPos3sv(v);
}

typedef void (*PFNRASTERPOS4DPROC_HPP)(GLdouble x,GLdouble y,GLdouble z,GLdouble w);

inline void RasterPos4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	 glRasterPos4d(x,y,z,w);
}

typedef void (*PFNRASTERPOS4DVPROC_HPP)(const GLdouble *v);

inline void RasterPos4dv(const GLdouble *v)
{
	 glRasterPos4dv(v);
}

typedef void (*PFNRASTERPOS4FPROC_HPP)(GLfloat x,GLfloat y,GLfloat z,GLfloat w);

inline void RasterPos4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	 glRasterPos4f(x,y,z,w);
}

typedef void (*PFNRASTERPOS4FVPROC_HPP)(const GLfloat *v);

inline void RasterPos4fv(const GLfloat *v)
{
	 glRasterPos4fv(v);
}

typedef void (*PFNRASTERPOS4IPROC_HPP)(GLint x,GLint y,GLint z,GLint w);

inline void RasterPos4i(GLint x,GLint y,GLint z,GLint w)
{
	 glRasterPos4i(x,y,z,w);
}

typedef void (*PFNRASTERPOS4IVPROC_HPP)(const GLint *v);

inline void RasterPos4iv(const GLint *v)
{
	 glRasterPos4iv(v);
}

typedef void (*PFNRASTERPOS4SPROC_HPP)(GLshort x,GLshort y,GLshort z,GLshort w);

inline void RasterPos4s(GLshort x,GLshort y,GLshort z,GLshort w)
{
	 glRasterPos4s(x,y,z,w);
}

typedef void (*PFNRASTERPOS4SVPROC_HPP)(const GLshort *v);

inline void RasterPos4sv(const GLshort *v)
{
	 glRasterPos4sv(v);
}

typedef void (*PFNRECTDPROC_HPP)(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2);

inline void Rectd(GLdouble x1,GLdouble y1,GLdouble x2,GLdouble y2)
{
	 glRectd(x1,y1,x2,y2);
}

typedef void (*PFNRECTDVPROC_HPP)(const GLdouble *v1,const GLdouble *v2);

inline void Rectdv(const GLdouble *v1,const GLdouble *v2)
{
	 glRectdv(v1,v2);
}

typedef void (*PFNRECTFPROC_HPP)(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2);

inline void Rectf(GLfloat x1,GLfloat y1,GLfloat x2,GLfloat y2)
{
	 glRectf(x1,y1,x2,y2);
}

typedef void (*PFNRECTFVPROC_HPP)(const GLfloat *v1,const GLfloat *v2);

inline void Rectfv(const GLfloat *v1,const GLfloat *v2)
{
	 glRectfv(v1,v2);
}

typedef void (*PFNRECTIPROC_HPP)(GLint x1,GLint y1,GLint x2,GLint y2);

inline void Recti(GLint x1,GLint y1,GLint x2,GLint y2)
{
	 glRecti(x1,y1,x2,y2);
}

typedef void (*PFNRECTIVPROC_HPP)(const GLint *v1,const GLint *v2);

inline void Rectiv(const GLint *v1,const GLint *v2)
{
	 glRectiv(v1,v2);
}

typedef void (*PFNRECTSPROC_HPP)(GLshort x1,GLshort y1,GLshort x2,GLshort y2);

inline void Rects(GLshort x1,GLshort y1,GLshort x2,GLshort y2)
{
	 glRects(x1,y1,x2,y2);
}

typedef void (*PFNRECTSVPROC_HPP)(const GLshort *v1,const GLshort *v2);

inline void Rectsv(const GLshort *v1,const GLshort *v2)
{
	 glRectsv(v1,v2);
}

typedef void (*PFNTEXCOORD1DPROC_HPP)(GLdouble s);

inline void TexCoord1d(GLdouble s)
{
	 glTexCoord1d(s);
}

typedef void (*PFNTEXCOORD1DVPROC_HPP)(const GLdouble *v);

inline void TexCoord1dv(const GLdouble *v)
{
	 glTexCoord1dv(v);
}

typedef void (*PFNTEXCOORD1FPROC_HPP)(GLfloat s);

inline void TexCoord1f(GLfloat s)
{
	 glTexCoord1f(s);
}

typedef void (*PFNTEXCOORD1FVPROC_HPP)(const GLfloat *v);

inline void TexCoord1fv(const GLfloat *v)
{
	 glTexCoord1fv(v);
}

typedef void (*PFNTEXCOORD1IPROC_HPP)(GLint s);

inline void TexCoord1i(GLint s)
{
	 glTexCoord1i(s);
}

typedef void (*PFNTEXCOORD1IVPROC_HPP)(const GLint *v);

inline void TexCoord1iv(const GLint *v)
{
	 glTexCoord1iv(v);
}

typedef void (*PFNTEXCOORD1SPROC_HPP)(GLshort s);

inline void TexCoord1s(GLshort s)
{
	 glTexCoord1s(s);
}

typedef void (*PFNTEXCOORD1SVPROC_HPP)(const GLshort *v);

inline void TexCoord1sv(const GLshort *v)
{
	 glTexCoord1sv(v);
}

typedef void (*PFNTEXCOORD2DPROC_HPP)(GLdouble s,GLdouble t);

inline void TexCoord2d(GLdouble s,GLdouble t)
{
	 glTexCoord2d(s,t);
}

typedef void (*PFNTEXCOORD2DVPROC_HPP)(const GLdouble *v);

inline void TexCoord2dv(const GLdouble *v)
{
	 glTexCoord2dv(v);
}

typedef void (*PFNTEXCOORD2FPROC_HPP)(GLfloat s,GLfloat t);

inline void TexCoord2f(GLfloat s,GLfloat t)
{
	 glTexCoord2f(s,t);
}

typedef void (*PFNTEXCOORD2FVPROC_HPP)(const GLfloat *v);

inline void TexCoord2fv(const GLfloat *v)
{
	 glTexCoord2fv(v);
}

typedef void (*PFNTEXCOORD2IPROC_HPP)(GLint s,GLint t);

inline void TexCoord2i(GLint s,GLint t)
{
	 glTexCoord2i(s,t);
}

typedef void (*PFNTEXCOORD2IVPROC_HPP)(const GLint *v);

inline void TexCoord2iv(const GLint *v)
{
	 glTexCoord2iv(v);
}

typedef void (*PFNTEXCOORD2SPROC_HPP)(GLshort s,GLshort t);

inline void TexCoord2s(GLshort s,GLshort t)
{
	 glTexCoord2s(s,t);
}

typedef void (*PFNTEXCOORD2SVPROC_HPP)(const GLshort *v);

inline void TexCoord2sv(const GLshort *v)
{
	 glTexCoord2sv(v);
}

typedef void (*PFNTEXCOORD3DPROC_HPP)(GLdouble s,GLdouble t,GLdouble r);

inline void TexCoord3d(GLdouble s,GLdouble t,GLdouble r)
{
	 glTexCoord3d(s,t,r);
}

typedef void (*PFNTEXCOORD3DVPROC_HPP)(const GLdouble *v);

inline void TexCoord3dv(const GLdouble *v)
{
	 glTexCoord3dv(v);
}

typedef void (*PFNTEXCOORD3FPROC_HPP)(GLfloat s,GLfloat t,GLfloat r);

inline void TexCoord3f(GLfloat s,GLfloat t,GLfloat r)
{
	 glTexCoord3f(s,t,r);
}

typedef void (*PFNTEXCOORD3FVPROC_HPP)(const GLfloat *v);

inline void TexCoord3fv(const GLfloat *v)
{
	 glTexCoord3fv(v);
}

typedef void (*PFNTEXCOORD3IPROC_HPP)(GLint s,GLint t,GLint r);

inline void TexCoord3i(GLint s,GLint t,GLint r)
{
	 glTexCoord3i(s,t,r);
}

typedef void (*PFNTEXCOORD3IVPROC_HPP)(const GLint *v);

inline void TexCoord3iv(const GLint *v)
{
	 glTexCoord3iv(v);
}

typedef void (*PFNTEXCOORD3SPROC_HPP)(GLshort s,GLshort t,GLshort r);

inline void TexCoord3s(GLshort s,GLshort t,GLshort r)
{
	 glTexCoord3s(s,t,r);
}

typedef void (*PFNTEXCOORD3SVPROC_HPP)(const GLshort *v);

inline void TexCoord3sv(const GLshort *v)
{
	 glTexCoord3sv(v);
}

typedef void (*PFNTEXCOORD4DPROC_HPP)(GLdouble s,GLdouble t,GLdouble r,GLdouble q);

inline void TexCoord4d(GLdouble s,GLdouble t,GLdouble r,GLdouble q)
{
	 glTexCoord4d(s,t,r,q);
}

typedef void (*PFNTEXCOORD4DVPROC_HPP)(const GLdouble *v);

inline void TexCoord4dv(const GLdouble *v)
{
	 glTexCoord4dv(v);
}

typedef void (*PFNTEXCOORD4FPROC_HPP)(GLfloat s,GLfloat t,GLfloat r,GLfloat q);

inline void TexCoord4f(GLfloat s,GLfloat t,GLfloat r,GLfloat q)
{
	 glTexCoord4f(s,t,r,q);
}

typedef void (*PFNTEXCOORD4FVPROC_HPP)(const GLfloat *v);

inline void TexCoord4fv(const GLfloat *v)
{
	 glTexCoord4fv(v);
}

typedef void (*PFNTEXCOORD4IPROC_HPP)(GLint s,GLint t,GLint r,GLint q);

inline void TexCoord4i(GLint s,GLint t,GLint r,GLint q)
{
	 glTexCoord4i(s,t,r,q);
}

typedef void (*PFNTEXCOORD4IVPROC_HPP)(const GLint *v);

inline void TexCoord4iv(const GLint *v)
{
	 glTexCoord4iv(v);
}

typedef void (*PFNTEXCOORD4SPROC_HPP)(GLshort s,GLshort t,GLshort r,GLshort q);

inline void TexCoord4s(GLshort s,GLshort t,GLshort r,GLshort q)
{
	 glTexCoord4s(s,t,r,q);
}

typedef void (*PFNTEXCOORD4SVPROC_HPP)(const GLshort *v);

inline void TexCoord4sv(const GLshort *v)
{
	 glTexCoord4sv(v);
}

typedef void (*PFNVERTEX2DPROC_HPP)(GLdouble x,GLdouble y);

inline void Vertex2d(GLdouble x,GLdouble y)
{
	 glVertex2d(x,y);
}

typedef void (*PFNVERTEX2DVPROC_HPP)(const GLdouble *v);

inline void Vertex2dv(const GLdouble *v)
{
	 glVertex2dv(v);
}

typedef void (*PFNVERTEX2FPROC_HPP)(GLfloat x,GLfloat y);

inline void Vertex2f(GLfloat x,GLfloat y)
{
	 glVertex2f(x,y);
}

typedef void (*PFNVERTEX2FVPROC_HPP)(const GLfloat *v);

inline void Vertex2fv(const GLfloat *v)
{
	 glVertex2fv(v);
}

typedef void (*PFNVERTEX2IPROC_HPP)(GLint x,GLint y);

inline void Vertex2i(GLint x,GLint y)
{
	 glVertex2i(x,y);
}

typedef void (*PFNVERTEX2IVPROC_HPP)(const GLint *v);

inline void Vertex2iv(const GLint *v)
{
	 glVertex2iv(v);
}

typedef void (*PFNVERTEX2SPROC_HPP)(GLshort x,GLshort y);

inline void Vertex2s(GLshort x,GLshort y)
{
	 glVertex2s(x,y);
}

typedef void (*PFNVERTEX2SVPROC_HPP)(const GLshort *v);

inline void Vertex2sv(const GLshort *v)
{
	 glVertex2sv(v);
}

typedef void (*PFNVERTEX3DPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

inline void Vertex3d(GLdouble x,GLdouble y,GLdouble z)
{
	 glVertex3d(x,y,z);
}

typedef void (*PFNVERTEX3DVPROC_HPP)(const GLdouble *v);

inline void Vertex3dv(const GLdouble *v)
{
	 glVertex3dv(v);
}

typedef void (*PFNVERTEX3FPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

inline void Vertex3f(GLfloat x,GLfloat y,GLfloat z)
{
	 glVertex3f(x,y,z);
}

typedef void (*PFNVERTEX3FVPROC_HPP)(const GLfloat *v);

inline void Vertex3fv(const GLfloat *v)
{
	 glVertex3fv(v);
}

typedef void (*PFNVERTEX3IPROC_HPP)(GLint x,GLint y,GLint z);

inline void Vertex3i(GLint x,GLint y,GLint z)
{
	 glVertex3i(x,y,z);
}

typedef void (*PFNVERTEX3IVPROC_HPP)(const GLint *v);

inline void Vertex3iv(const GLint *v)
{
	 glVertex3iv(v);
}

typedef void (*PFNVERTEX3SPROC_HPP)(GLshort x,GLshort y,GLshort z);

inline void Vertex3s(GLshort x,GLshort y,GLshort z)
{
	 glVertex3s(x,y,z);
}

typedef void (*PFNVERTEX3SVPROC_HPP)(const GLshort *v);

inline void Vertex3sv(const GLshort *v)
{
	 glVertex3sv(v);
}

typedef void (*PFNVERTEX4DPROC_HPP)(GLdouble x,GLdouble y,GLdouble z,GLdouble w);

inline void Vertex4d(GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	 glVertex4d(x,y,z,w);
}

typedef void (*PFNVERTEX4DVPROC_HPP)(const GLdouble *v);

inline void Vertex4dv(const GLdouble *v)
{
	 glVertex4dv(v);
}

typedef void (*PFNVERTEX4FPROC_HPP)(GLfloat x,GLfloat y,GLfloat z,GLfloat w);

inline void Vertex4f(GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	 glVertex4f(x,y,z,w);
}

typedef void (*PFNVERTEX4FVPROC_HPP)(const GLfloat *v);

inline void Vertex4fv(const GLfloat *v)
{
	 glVertex4fv(v);
}

typedef void (*PFNVERTEX4IPROC_HPP)(GLint x,GLint y,GLint z,GLint w);

inline void Vertex4i(GLint x,GLint y,GLint z,GLint w)
{
	 glVertex4i(x,y,z,w);
}

typedef void (*PFNVERTEX4IVPROC_HPP)(const GLint *v);

inline void Vertex4iv(const GLint *v)
{
	 glVertex4iv(v);
}

typedef void (*PFNVERTEX4SPROC_HPP)(GLshort x,GLshort y,GLshort z,GLshort w);

inline void Vertex4s(GLshort x,GLshort y,GLshort z,GLshort w)
{
	 glVertex4s(x,y,z,w);
}

typedef void (*PFNVERTEX4SVPROC_HPP)(const GLshort *v);

inline void Vertex4sv(const GLshort *v)
{
	 glVertex4sv(v);
}

typedef void (*PFNCLIPPLANEPROC_HPP)(GLenum plane,const GLdouble *equation);

inline void ClipPlane(GLenum plane,const GLdouble *equation)
{
	 glClipPlane(plane,equation);
}

typedef void (*PFNCOLORMATERIALPROC_HPP)(GLenum face,GLenum mode);

inline void ColorMaterial(GLenum face,GLenum mode)
{
	 glColorMaterial(face,mode);
}

typedef void (*PFNFOGFPROC_HPP)(GLenum pname,GLfloat param);

inline void Fogf(GLenum pname,GLfloat param)
{
	 glFogf(pname,param);
}

typedef void (*PFNFOGFVPROC_HPP)(GLenum pname,const GLfloat *params);

inline void Fogfv(GLenum pname,const GLfloat *params)
{
	 glFogfv(pname,params);
}

typedef void (*PFNFOGIPROC_HPP)(GLenum pname,GLint param);

inline void Fogi(GLenum pname,GLint param)
{
	 glFogi(pname,param);
}

typedef void (*PFNFOGIVPROC_HPP)(GLenum pname,const GLint *params);

inline void Fogiv(GLenum pname,const GLint *params)
{
	 glFogiv(pname,params);
}

typedef void (*PFNLIGHTFPROC_HPP)(GLenum light,GLenum pname,GLfloat param);

inline void Lightf(GLenum light,GLenum pname,GLfloat param)
{
	 glLightf(light,pname,param);
}

typedef void (*PFNLIGHTFVPROC_HPP)(GLenum light,GLenum pname,const GLfloat *params);

inline void Lightfv(GLenum light,GLenum pname,const GLfloat *params)
{
	 glLightfv(light,pname,params);
}

typedef void (*PFNLIGHTIPROC_HPP)(GLenum light,GLenum pname,GLint param);

inline void Lighti(GLenum light,GLenum pname,GLint param)
{
	 glLighti(light,pname,param);
}

typedef void (*PFNLIGHTIVPROC_HPP)(GLenum light,GLenum pname,const GLint *params);

inline void Lightiv(GLenum light,GLenum pname,const GLint *params)
{
	 glLightiv(light,pname,params);
}

typedef void (*PFNLIGHTMODELFPROC_HPP)(GLenum pname,GLfloat param);

inline void LightModelf(GLenum pname,GLfloat param)
{
	 glLightModelf(pname,param);
}

typedef void (*PFNLIGHTMODELFVPROC_HPP)(GLenum pname,const GLfloat *params);

inline void LightModelfv(GLenum pname,const GLfloat *params)
{
	 glLightModelfv(pname,params);
}

typedef void (*PFNLIGHTMODELIPROC_HPP)(GLenum pname,GLint param);

inline void LightModeli(GLenum pname,GLint param)
{
	 glLightModeli(pname,param);
}

typedef void (*PFNLIGHTMODELIVPROC_HPP)(GLenum pname,const GLint *params);

inline void LightModeliv(GLenum pname,const GLint *params)
{
	 glLightModeliv(pname,params);
}

typedef void (*PFNLINESTIPPLEPROC_HPP)(GLint factor,GLushort pattern);

inline void LineStipple(GLint factor,GLushort pattern)
{
	 glLineStipple(factor,pattern);
}

typedef void (*PFNMATERIALFPROC_HPP)(GLenum face,GLenum pname,GLfloat param);

inline void Materialf(GLenum face,GLenum pname,GLfloat param)
{
	 glMaterialf(face,pname,param);
}

typedef void (*PFNMATERIALFVPROC_HPP)(GLenum face,GLenum pname,const GLfloat *params);

inline void Materialfv(GLenum face,GLenum pname,const GLfloat *params)
{
	 glMaterialfv(face,pname,params);
}

typedef void (*PFNMATERIALIPROC_HPP)(GLenum face,GLenum pname,GLint param);

inline void Materiali(GLenum face,GLenum pname,GLint param)
{
	 glMateriali(face,pname,param);
}

typedef void (*PFNMATERIALIVPROC_HPP)(GLenum face,GLenum pname,const GLint *params);

inline void Materialiv(GLenum face,GLenum pname,const GLint *params)
{
	 glMaterialiv(face,pname,params);
}

typedef void (*PFNPOLYGONSTIPPLEPROC_HPP)(const GLubyte *mask);

inline void PolygonStipple(const GLubyte *mask)
{
	 glPolygonStipple(mask);
}

typedef void (*PFNSHADEMODELPROC_HPP)(GLenum mode);

inline void ShadeModel(GLenum mode)
{
	 glShadeModel(mode);
}

typedef void (*PFNTEXENVFPROC_HPP)(GLenum target,GLenum pname,GLfloat param);

inline void TexEnvf(GLenum target,GLenum pname,GLfloat param)
{
	 glTexEnvf(target,pname,param);
}

typedef void (*PFNTEXENVFVPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

inline void TexEnvfv(GLenum target,GLenum pname,const GLfloat *params)
{
	 glTexEnvfv(target,pname,params);
}

typedef void (*PFNTEXENVIPROC_HPP)(GLenum target,GLenum pname,GLint param);

inline void TexEnvi(GLenum target,GLenum pname,GLint param)
{
	 glTexEnvi(target,pname,param);
}

typedef void (*PFNTEXENVIVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

inline void TexEnviv(GLenum target,GLenum pname,const GLint *params)
{
	 glTexEnviv(target,pname,params);
}

typedef void (*PFNTEXGENDPROC_HPP)(GLenum coord,GLenum pname,GLdouble param);

inline void TexGend(GLenum coord,GLenum pname,GLdouble param)
{
	 glTexGend(coord,pname,param);
}

typedef void (*PFNTEXGENDVPROC_HPP)(GLenum coord,GLenum pname,const GLdouble *params);

inline void TexGendv(GLenum coord,GLenum pname,const GLdouble *params)
{
	 glTexGendv(coord,pname,params);
}

typedef void (*PFNTEXGENFPROC_HPP)(GLenum coord,GLenum pname,GLfloat param);

inline void TexGenf(GLenum coord,GLenum pname,GLfloat param)
{
	 glTexGenf(coord,pname,param);
}

typedef void (*PFNTEXGENFVPROC_HPP)(GLenum coord,GLenum pname,const GLfloat *params);

inline void TexGenfv(GLenum coord,GLenum pname,const GLfloat *params)
{
	 glTexGenfv(coord,pname,params);
}

typedef void (*PFNTEXGENIPROC_HPP)(GLenum coord,GLenum pname,GLint param);

inline void TexGeni(GLenum coord,GLenum pname,GLint param)
{
	 glTexGeni(coord,pname,param);
}

typedef void (*PFNTEXGENIVPROC_HPP)(GLenum coord,GLenum pname,const GLint *params);

inline void TexGeniv(GLenum coord,GLenum pname,const GLint *params)
{
	 glTexGeniv(coord,pname,params);
}

typedef void (*PFNFEEDBACKBUFFERPROC_HPP)(GLsizei size,GLenum type,GLfloat *buffer);

inline void FeedbackBuffer(GLsizei size,GLenum type,GLfloat *buffer)
{
	 glFeedbackBuffer(size,type,buffer);
}

typedef void (*PFNSELECTBUFFERPROC_HPP)(GLsizei size,GLuint *buffer);

inline void SelectBuffer(GLsizei size,GLuint *buffer)
{
	 glSelectBuffer(size,buffer);
}

typedef GLint (*PFNRENDERMODEPROC_HPP)(GLenum mode);

inline GLint RenderMode(GLenum mode)
{
	return glRenderMode(mode);
}

typedef void (*PFNINITNAMESPROC_HPP)();

inline void InitNames()
{
	 glInitNames();
}

typedef void (*PFNLOADNAMEPROC_HPP)(GLuint name);

inline void LoadName(GLuint name)
{
	 glLoadName(name);
}

typedef void (*PFNPASSTHROUGHPROC_HPP)(GLfloat token);

inline void PassThrough(GLfloat token)
{
	 glPassThrough(token);
}

typedef void (*PFNPOPNAMEPROC_HPP)();

inline void PopName()
{
	 glPopName();
}

typedef void (*PFNPUSHNAMEPROC_HPP)(GLuint name);

inline void PushName(GLuint name)
{
	 glPushName(name);
}

typedef void (*PFNCLEARACCUMPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);

inline void ClearAccum(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)
{
	 glClearAccum(red,green,blue,alpha);
}

typedef void (*PFNCLEARINDEXPROC_HPP)(GLfloat c);

inline void ClearIndex(GLfloat c)
{
	 glClearIndex(c);
}

typedef void (*PFNINDEXMASKPROC_HPP)(GLuint mask);

inline void IndexMask(GLuint mask)
{
	 glIndexMask(mask);
}

typedef void (*PFNACCUMPROC_HPP)(GLenum op,GLfloat value);

inline void Accum(GLenum op,GLfloat value)
{
	 glAccum(op,value);
}

typedef void (*PFNPOPATTRIBPROC_HPP)();

inline void PopAttrib()
{
	 glPopAttrib();
}

typedef void (*PFNPUSHATTRIBPROC_HPP)(GLbitfield mask);

inline void PushAttrib(GLbitfield mask)
{
	 glPushAttrib(mask);
}

typedef void (*PFNMAP1DPROC_HPP)(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble *points);

inline void Map1d(GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble *points)
{
	 glMap1d(target,u1,u2,stride,order,points);
}

typedef void (*PFNMAP1FPROC_HPP)(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat *points);

inline void Map1f(GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat *points)
{
	 glMap1f(target,u1,u2,stride,order,points);
}

typedef void (*PFNMAP2DPROC_HPP)(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble *points);

inline void Map2d(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble *points)
{
	 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
}

typedef void (*PFNMAP2FPROC_HPP)(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat *points);

inline void Map2f(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat *points)
{
	 glMap2f(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
}

typedef void (*PFNMAPGRID1DPROC_HPP)(GLint un,GLdouble u1,GLdouble u2);

inline void MapGrid1d(GLint un,GLdouble u1,GLdouble u2)
{
	 glMapGrid1d(un,u1,u2);
}

typedef void (*PFNMAPGRID1FPROC_HPP)(GLint un,GLfloat u1,GLfloat u2);

inline void MapGrid1f(GLint un,GLfloat u1,GLfloat u2)
{
	 glMapGrid1f(un,u1,u2);
}

typedef void (*PFNMAPGRID2DPROC_HPP)(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2);

inline void MapGrid2d(GLint un,GLdouble u1,GLdouble u2,GLint vn,GLdouble v1,GLdouble v2)
{
	 glMapGrid2d(un,u1,u2,vn,v1,v2);
}

typedef void (*PFNMAPGRID2FPROC_HPP)(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2);

inline void MapGrid2f(GLint un,GLfloat u1,GLfloat u2,GLint vn,GLfloat v1,GLfloat v2)
{
	 glMapGrid2f(un,u1,u2,vn,v1,v2);
}

typedef void (*PFNEVALCOORD1DPROC_HPP)(GLdouble u);

inline void EvalCoord1d(GLdouble u)
{
	 glEvalCoord1d(u);
}

typedef void (*PFNEVALCOORD1DVPROC_HPP)(const GLdouble *u);

inline void EvalCoord1dv(const GLdouble *u)
{
	 glEvalCoord1dv(u);
}

typedef void (*PFNEVALCOORD1FPROC_HPP)(GLfloat u);

inline void EvalCoord1f(GLfloat u)
{
	 glEvalCoord1f(u);
}

typedef void (*PFNEVALCOORD1FVPROC_HPP)(const GLfloat *u);

inline void EvalCoord1fv(const GLfloat *u)
{
	 glEvalCoord1fv(u);
}

typedef void (*PFNEVALCOORD2DPROC_HPP)(GLdouble u,GLdouble v);

inline void EvalCoord2d(GLdouble u,GLdouble v)
{
	 glEvalCoord2d(u,v);
}

typedef void (*PFNEVALCOORD2DVPROC_HPP)(const GLdouble *u);

inline void EvalCoord2dv(const GLdouble *u)
{
	 glEvalCoord2dv(u);
}

typedef void (*PFNEVALCOORD2FPROC_HPP)(GLfloat u,GLfloat v);

inline void EvalCoord2f(GLfloat u,GLfloat v)
{
	 glEvalCoord2f(u,v);
}

typedef void (*PFNEVALCOORD2FVPROC_HPP)(const GLfloat *u);

inline void EvalCoord2fv(const GLfloat *u)
{
	 glEvalCoord2fv(u);
}

typedef void (*PFNEVALMESH1PROC_HPP)(GLenum mode,GLint i1,GLint i2);

inline void EvalMesh1(GLenum mode,GLint i1,GLint i2)
{
	 glEvalMesh1(mode,i1,i2);
}

typedef void (*PFNEVALPOINT1PROC_HPP)(GLint i);

inline void EvalPoint1(GLint i)
{
	 glEvalPoint1(i);
}

typedef void (*PFNEVALMESH2PROC_HPP)(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2);

inline void EvalMesh2(GLenum mode,GLint i1,GLint i2,GLint j1,GLint j2)
{
	 glEvalMesh2(mode,i1,i2,j1,j2);
}

typedef void (*PFNEVALPOINT2PROC_HPP)(GLint i,GLint j);

inline void EvalPoint2(GLint i,GLint j)
{
	 glEvalPoint2(i,j);
}

typedef void (*PFNALPHAFUNCPROC_HPP)(GLenum func,GLfloat ref);

inline void AlphaFunc(GLenum func,GLfloat ref)
{
	 glAlphaFunc(func,ref);
}

typedef void (*PFNPIXELZOOMPROC_HPP)(GLfloat xfactor,GLfloat yfactor);

inline void PixelZoom(GLfloat xfactor,GLfloat yfactor)
{
	 glPixelZoom(xfactor,yfactor);
}

typedef void (*PFNPIXELTRANSFERFPROC_HPP)(GLenum pname,GLfloat param);

inline void PixelTransferf(GLenum pname,GLfloat param)
{
	 glPixelTransferf(pname,param);
}

typedef void (*PFNPIXELTRANSFERIPROC_HPP)(GLenum pname,GLint param);

inline void PixelTransferi(GLenum pname,GLint param)
{
	 glPixelTransferi(pname,param);
}

typedef void (*PFNPIXELMAPFVPROC_HPP)(GLenum map,GLsizei mapsize,const GLfloat *values);

inline void PixelMapfv(GLenum map,GLsizei mapsize,const GLfloat *values)
{
	 glPixelMapfv(map,mapsize,values);
}

typedef void (*PFNPIXELMAPUIVPROC_HPP)(GLenum map,GLsizei mapsize,const GLuint *values);

inline void PixelMapuiv(GLenum map,GLsizei mapsize,const GLuint *values)
{
	 glPixelMapuiv(map,mapsize,values);
}

typedef void (*PFNPIXELMAPUSVPROC_HPP)(GLenum map,GLsizei mapsize,const GLushort *values);

inline void PixelMapusv(GLenum map,GLsizei mapsize,const GLushort *values)
{
	 glPixelMapusv(map,mapsize,values);
}

typedef void (*PFNCOPYPIXELSPROC_HPP)(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type);

inline void CopyPixels(GLint x,GLint y,GLsizei width,GLsizei height,GLenum type)
{
	 glCopyPixels(x,y,width,height,type);
}

typedef void (*PFNDRAWPIXELSPROC_HPP)(GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels);

inline void DrawPixels(GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels)
{
	 glDrawPixels(width,height,format,type,pixels);
}

typedef void (*PFNGETCLIPPLANEPROC_HPP)(GLenum plane,GLdouble *equation);

inline void GetClipPlane(GLenum plane,GLdouble *equation)
{
	 glGetClipPlane(plane,equation);
}

typedef void (*PFNGETLIGHTFVPROC_HPP)(GLenum light,GLenum pname,GLfloat *params);

inline void GetLightfv(GLenum light,GLenum pname,GLfloat *params)
{
	 glGetLightfv(light,pname,params);
}

typedef void (*PFNGETLIGHTIVPROC_HPP)(GLenum light,GLenum pname,GLint *params);

inline void GetLightiv(GLenum light,GLenum pname,GLint *params)
{
	 glGetLightiv(light,pname,params);
}

typedef void (*PFNGETMAPDVPROC_HPP)(GLenum target,GLenum query,GLdouble *v);

inline void GetMapdv(GLenum target,GLenum query,GLdouble *v)
{
	 glGetMapdv(target,query,v);
}

typedef void (*PFNGETMAPFVPROC_HPP)(GLenum target,GLenum query,GLfloat *v);

inline void GetMapfv(GLenum target,GLenum query,GLfloat *v)
{
	 glGetMapfv(target,query,v);
}

typedef void (*PFNGETMAPIVPROC_HPP)(GLenum target,GLenum query,GLint *v);

inline void GetMapiv(GLenum target,GLenum query,GLint *v)
{
	 glGetMapiv(target,query,v);
}

typedef void (*PFNGETMATERIALFVPROC_HPP)(GLenum face,GLenum pname,GLfloat *params);

inline void GetMaterialfv(GLenum face,GLenum pname,GLfloat *params)
{
	 glGetMaterialfv(face,pname,params);
}

typedef void (*PFNGETMATERIALIVPROC_HPP)(GLenum face,GLenum pname,GLint *params);

inline void GetMaterialiv(GLenum face,GLenum pname,GLint *params)
{
	 glGetMaterialiv(face,pname,params);
}

typedef void (*PFNGETPIXELMAPFVPROC_HPP)(GLenum map,GLfloat *values);

inline void GetPixelMapfv(GLenum map,GLfloat *values)
{
	 glGetPixelMapfv(map,values);
}

typedef void (*PFNGETPIXELMAPUIVPROC_HPP)(GLenum map,GLuint *values);

inline void GetPixelMapuiv(GLenum map,GLuint *values)
{
	 glGetPixelMapuiv(map,values);
}

typedef void (*PFNGETPIXELMAPUSVPROC_HPP)(GLenum map,GLushort *values);

inline void GetPixelMapusv(GLenum map,GLushort *values)
{
	 glGetPixelMapusv(map,values);
}

typedef void (*PFNGETPOLYGONSTIPPLEPROC_HPP)(GLubyte *mask);

inline void GetPolygonStipple(GLubyte *mask)
{
	 glGetPolygonStipple(mask);
}

typedef void (*PFNGETTEXENVFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

inline void GetTexEnvfv(GLenum target,GLenum pname,GLfloat *params)
{
	 glGetTexEnvfv(target,pname,params);
}

typedef void (*PFNGETTEXENVIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

inline void GetTexEnviv(GLenum target,GLenum pname,GLint *params)
{
	 glGetTexEnviv(target,pname,params);
}

typedef void (*PFNGETTEXGENDVPROC_HPP)(GLenum coord,GLenum pname,GLdouble *params);

inline void GetTexGendv(GLenum coord,GLenum pname,GLdouble *params)
{
	 glGetTexGendv(coord,pname,params);
}

typedef void (*PFNGETTEXGENFVPROC_HPP)(GLenum coord,GLenum pname,GLfloat *params);

inline void GetTexGenfv(GLenum coord,GLenum pname,GLfloat *params)
{
	 glGetTexGenfv(coord,pname,params);
}

typedef void (*PFNGETTEXGENIVPROC_HPP)(GLenum coord,GLenum pname,GLint *params);

inline void GetTexGeniv(GLenum coord,GLenum pname,GLint *params)
{
	 glGetTexGeniv(coord,pname,params);
}

typedef GLboolean (*PFNISLISTPROC_HPP)(GLuint list);

inline GLboolean IsList(GLuint list)
{
	return glIsList(list);
}

typedef void (*PFNFRUSTUMPROC_HPP)(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);

inline void Frustum(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)
{
	 glFrustum(left,right,bottom,top,zNear,zFar);
}

typedef void (*PFNLOADIDENTITYPROC_HPP)();

inline void LoadIdentity()
{
	 glLoadIdentity();
}

typedef void (*PFNLOADMATRIXFPROC_HPP)(const GLfloat *m);

inline void LoadMatrixf(const GLfloat *m)
{
	 glLoadMatrixf(m);
}

typedef void (*PFNLOADMATRIXDPROC_HPP)(const GLdouble *m);

inline void LoadMatrixd(const GLdouble *m)
{
	 glLoadMatrixd(m);
}

typedef void (*PFNMATRIXMODEPROC_HPP)(GLenum mode);

inline void MatrixMode(GLenum mode)
{
	 glMatrixMode(mode);
}

typedef void (*PFNMULTMATRIXFPROC_HPP)(const GLfloat *m);

inline void MultMatrixf(const GLfloat *m)
{
	 glMultMatrixf(m);
}

typedef void (*PFNMULTMATRIXDPROC_HPP)(const GLdouble *m);

inline void MultMatrixd(const GLdouble *m)
{
	 glMultMatrixd(m);
}

typedef void (*PFNORTHOPROC_HPP)(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);

inline void Ortho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)
{
	 glOrtho(left,right,bottom,top,zNear,zFar);
}

typedef void (*PFNPOPMATRIXPROC_HPP)();

inline void PopMatrix()
{
	 glPopMatrix();
}

typedef void (*PFNPUSHMATRIXPROC_HPP)();

inline void PushMatrix()
{
	 glPushMatrix();
}

typedef void (*PFNROTATEDPROC_HPP)(GLdouble angle,GLdouble x,GLdouble y,GLdouble z);

inline void Rotated(GLdouble angle,GLdouble x,GLdouble y,GLdouble z)
{
	 glRotated(angle,x,y,z);
}

typedef void (*PFNROTATEFPROC_HPP)(GLfloat angle,GLfloat x,GLfloat y,GLfloat z);

inline void Rotatef(GLfloat angle,GLfloat x,GLfloat y,GLfloat z)
{
	 glRotatef(angle,x,y,z);
}

typedef void (*PFNSCALEDPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

inline void Scaled(GLdouble x,GLdouble y,GLdouble z)
{
	 glScaled(x,y,z);
}

typedef void (*PFNSCALEFPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

inline void Scalef(GLfloat x,GLfloat y,GLfloat z)
{
	 glScalef(x,y,z);
}

typedef void (*PFNTRANSLATEDPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

inline void Translated(GLdouble x,GLdouble y,GLdouble z)
{
	 glTranslated(x,y,z);
}

typedef void (*PFNTRANSLATEFPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

inline void Translatef(GLfloat x,GLfloat y,GLfloat z)
{
	 glTranslatef(x,y,z);
}
#endif //(GLPROC_VERSION >= 10)
#if (GLPROC_VERSION >= 11)

#ifndef GL_VERSION_1_1

#define GL_VERSION_1_1

#endif //GL_VERSION_1_1


typedef void (*PFNDRAWARRAYSPROC_HPP)(GLenum mode,GLint first,GLsizei count);

inline void DrawArrays(GLenum mode,GLint first,GLsizei count)
{
	 glDrawArrays(mode,first,count);
}

typedef void (*PFNDRAWELEMENTSPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices);

inline void DrawElements(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices)
{
	 glDrawElements(mode,count,type,indices);
}

typedef void (*PFNGETPOINTERVPROC_HPP)(GLenum pname,GLvoid* *params);

inline void GetPointerv(GLenum pname,GLvoid* *params)
{
	 glGetPointerv(pname,params);
}

typedef void (*PFNPOLYGONOFFSETPROC_HPP)(GLfloat factor,GLfloat units);

inline void PolygonOffset(GLfloat factor,GLfloat units)
{
	 glPolygonOffset(factor,units);
}

typedef void (*PFNCOPYTEXIMAGE1DPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);

inline void CopyTexImage1D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border)
{
	 glCopyTexImage1D(target,level,internalformat,x,y,width,border);
}

typedef void (*PFNCOPYTEXIMAGE2DPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);

inline void CopyTexImage2D(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)
{
	 glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
}

typedef void (*PFNCOPYTEXSUBIMAGE1DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);

inline void CopyTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)
{
	 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
}

typedef void (*PFNCOPYTEXSUBIMAGE2DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);

inline void CopyTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
}

typedef void (*PFNTEXSUBIMAGE1DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels);

inline void TexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels)
{
	 glTexSubImage1D(target,level,xoffset,width,format,type,pixels);
}

typedef void (*PFNTEXSUBIMAGE2DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels);

inline void TexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels)
{
	 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
}

typedef void (*PFNBINDTEXTUREPROC_HPP)(GLenum target,GLuint texture);

inline void BindTexture(GLenum target,GLuint texture)
{
	 glBindTexture(target,texture);
}

typedef void (*PFNDELETETEXTURESPROC_HPP)(GLsizei n,const GLuint *textures);

inline void DeleteTextures(GLsizei n,const GLuint *textures)
{
	 glDeleteTextures(n,textures);
}

typedef void (*PFNGENTEXTURESPROC_HPP)(GLsizei n,GLuint *textures);

inline void GenTextures(GLsizei n,GLuint *textures)
{
	 glGenTextures(n,textures);
}

typedef GLboolean (*PFNISTEXTUREPROC_HPP)(GLuint texture);

inline GLboolean IsTexture(GLuint texture)
{
	return glIsTexture(texture);
}

typedef void (*PFNARRAYELEMENTPROC_HPP)(GLint i);

inline void ArrayElement(GLint i)
{
	 glArrayElement(i);
}

typedef void (*PFNCOLORPOINTERPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

inline void ColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	 glColorPointer(size,type,stride,pointer);
}

typedef void (*PFNDISABLECLIENTSTATEPROC_HPP)(GLenum array);

inline void DisableClientState(GLenum array)
{
	 glDisableClientState(array);
}

typedef void (*PFNEDGEFLAGPOINTERPROC_HPP)(GLsizei stride,const GLvoid *pointer);

inline void EdgeFlagPointer(GLsizei stride,const GLvoid *pointer)
{
	 glEdgeFlagPointer(stride,pointer);
}

typedef void (*PFNENABLECLIENTSTATEPROC_HPP)(GLenum array);

inline void EnableClientState(GLenum array)
{
	 glEnableClientState(array);
}

typedef void (*PFNINDEXPOINTERPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

inline void IndexPointer(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	 glIndexPointer(type,stride,pointer);
}

typedef void (*PFNINTERLEAVEDARRAYSPROC_HPP)(GLenum format,GLsizei stride,const GLvoid *pointer);

inline void InterleavedArrays(GLenum format,GLsizei stride,const GLvoid *pointer)
{
	 glInterleavedArrays(format,stride,pointer);
}

typedef void (*PFNNORMALPOINTERPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

inline void NormalPointer(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	 glNormalPointer(type,stride,pointer);
}

typedef void (*PFNTEXCOORDPOINTERPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

inline void TexCoordPointer(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	 glTexCoordPointer(size,type,stride,pointer);
}

typedef void (*PFNVERTEXPOINTERPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

inline void VertexPointer(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	 glVertexPointer(size,type,stride,pointer);
}

typedef GLboolean (*PFNARETEXTURESRESIDENTPROC_HPP)(GLsizei n,const GLuint *textures,GLboolean *residences);

inline GLboolean AreTexturesResident(GLsizei n,const GLuint *textures,GLboolean *residences)
{
	return glAreTexturesResident(n,textures,residences);
}

typedef void (*PFNPRIORITIZETEXTURESPROC_HPP)(GLsizei n,const GLuint *textures,const GLfloat *priorities);

inline void PrioritizeTextures(GLsizei n,const GLuint *textures,const GLfloat *priorities)
{
	 glPrioritizeTextures(n,textures,priorities);
}

typedef void (*PFNINDEXUBPROC_HPP)(GLubyte c);

inline void Indexub(GLubyte c)
{
	 glIndexub(c);
}

typedef void (*PFNINDEXUBVPROC_HPP)(const GLubyte *c);

inline void Indexubv(const GLubyte *c)
{
	 glIndexubv(c);
}

typedef void (*PFNPOPCLIENTATTRIBPROC_HPP)();

inline void PopClientAttrib()
{
	 glPopClientAttrib();
}

typedef void (*PFNPUSHCLIENTATTRIBPROC_HPP)(GLbitfield mask);

inline void PushClientAttrib(GLbitfield mask)
{
	 glPushClientAttrib(mask);
}
#endif //(GLPROC_VERSION >= 11)
#if (GLPROC_VERSION >= 12)

#ifndef GL_VERSION_1_2

#define GL_VERSION_1_2
#ifndef GL_SMOOTH_POINT_SIZE_RANGE
#define GL_SMOOTH_POINT_SIZE_RANGE                                      0x0B12
#endif //GL_SMOOTH_POINT_SIZE_RANGE
#ifndef GL_SMOOTH_POINT_SIZE_GRANULARITY
#define GL_SMOOTH_POINT_SIZE_GRANULARITY                                0x0B13
#endif //GL_SMOOTH_POINT_SIZE_GRANULARITY
#ifndef GL_SMOOTH_LINE_WIDTH_RANGE
#define GL_SMOOTH_LINE_WIDTH_RANGE                                      0x0B22
#endif //GL_SMOOTH_LINE_WIDTH_RANGE
#ifndef GL_SMOOTH_LINE_WIDTH_GRANULARITY
#define GL_SMOOTH_LINE_WIDTH_GRANULARITY                                0x0B23
#endif //GL_SMOOTH_LINE_WIDTH_GRANULARITY
#ifndef GL_CONSTANT_COLOR
#define GL_CONSTANT_COLOR                                               0x8001
#endif //GL_CONSTANT_COLOR
#ifndef GL_ONE_MINUS_CONSTANT_COLOR
#define GL_ONE_MINUS_CONSTANT_COLOR                                     0x8002
#endif //GL_ONE_MINUS_CONSTANT_COLOR
#ifndef GL_CONSTANT_ALPHA
#define GL_CONSTANT_ALPHA                                               0x8003
#endif //GL_CONSTANT_ALPHA
#ifndef GL_ONE_MINUS_CONSTANT_ALPHA
#define GL_ONE_MINUS_CONSTANT_ALPHA                                     0x8004
#endif //GL_ONE_MINUS_CONSTANT_ALPHA
#ifndef GL_BLEND_COLOR
#define GL_BLEND_COLOR                                                  0x8005
#endif //GL_BLEND_COLOR
#ifndef GL_CONVOLUTION_1D
#define GL_CONVOLUTION_1D                                               0x8010
#endif //GL_CONVOLUTION_1D
#ifndef GL_CONVOLUTION_2D
#define GL_CONVOLUTION_2D                                               0x8011
#endif //GL_CONVOLUTION_2D
#ifndef GL_SEPARABLE_2D
#define GL_SEPARABLE_2D                                                 0x8012
#endif //GL_SEPARABLE_2D
#ifndef GL_CONVOLUTION_BORDER_MODE
#define GL_CONVOLUTION_BORDER_MODE                                      0x8013
#endif //GL_CONVOLUTION_BORDER_MODE
#ifndef GL_CONVOLUTION_FILTER_SCALE
#define GL_CONVOLUTION_FILTER_SCALE                                     0x8014
#endif //GL_CONVOLUTION_FILTER_SCALE
#ifndef GL_CONVOLUTION_FILTER_BIAS
#define GL_CONVOLUTION_FILTER_BIAS                                      0x8015
#endif //GL_CONVOLUTION_FILTER_BIAS
#ifndef GL_REDUCE
#define GL_REDUCE                                                       0x8016
#endif //GL_REDUCE
#ifndef GL_CONVOLUTION_FORMAT
#define GL_CONVOLUTION_FORMAT                                           0x8017
#endif //GL_CONVOLUTION_FORMAT
#ifndef GL_CONVOLUTION_WIDTH
#define GL_CONVOLUTION_WIDTH                                            0x8018
#endif //GL_CONVOLUTION_WIDTH
#ifndef GL_CONVOLUTION_HEIGHT
#define GL_CONVOLUTION_HEIGHT                                           0x8019
#endif //GL_CONVOLUTION_HEIGHT
#ifndef GL_MAX_CONVOLUTION_WIDTH
#define GL_MAX_CONVOLUTION_WIDTH                                        0x801A
#endif //GL_MAX_CONVOLUTION_WIDTH
#ifndef GL_MAX_CONVOLUTION_HEIGHT
#define GL_MAX_CONVOLUTION_HEIGHT                                       0x801B
#endif //GL_MAX_CONVOLUTION_HEIGHT
#ifndef GL_POST_CONVOLUTION_RED_SCALE
#define GL_POST_CONVOLUTION_RED_SCALE                                   0x801C
#endif //GL_POST_CONVOLUTION_RED_SCALE
#ifndef GL_POST_CONVOLUTION_GREEN_SCALE
#define GL_POST_CONVOLUTION_GREEN_SCALE                                 0x801D
#endif //GL_POST_CONVOLUTION_GREEN_SCALE
#ifndef GL_POST_CONVOLUTION_BLUE_SCALE
#define GL_POST_CONVOLUTION_BLUE_SCALE                                  0x801E
#endif //GL_POST_CONVOLUTION_BLUE_SCALE
#ifndef GL_POST_CONVOLUTION_ALPHA_SCALE
#define GL_POST_CONVOLUTION_ALPHA_SCALE                                 0x801F
#endif //GL_POST_CONVOLUTION_ALPHA_SCALE
#ifndef GL_POST_CONVOLUTION_RED_BIAS
#define GL_POST_CONVOLUTION_RED_BIAS                                    0x8020
#endif //GL_POST_CONVOLUTION_RED_BIAS
#ifndef GL_POST_CONVOLUTION_GREEN_BIAS
#define GL_POST_CONVOLUTION_GREEN_BIAS                                  0x8021
#endif //GL_POST_CONVOLUTION_GREEN_BIAS
#ifndef GL_POST_CONVOLUTION_BLUE_BIAS
#define GL_POST_CONVOLUTION_BLUE_BIAS                                   0x8022
#endif //GL_POST_CONVOLUTION_BLUE_BIAS
#ifndef GL_POST_CONVOLUTION_ALPHA_BIAS
#define GL_POST_CONVOLUTION_ALPHA_BIAS                                  0x8023
#endif //GL_POST_CONVOLUTION_ALPHA_BIAS
#ifndef GL_HISTOGRAM
#define GL_HISTOGRAM                                                    0x8024
#endif //GL_HISTOGRAM
#ifndef GL_PROXY_HISTOGRAM
#define GL_PROXY_HISTOGRAM                                              0x8025
#endif //GL_PROXY_HISTOGRAM
#ifndef GL_HISTOGRAM_WIDTH
#define GL_HISTOGRAM_WIDTH                                              0x8026
#endif //GL_HISTOGRAM_WIDTH
#ifndef GL_HISTOGRAM_FORMAT
#define GL_HISTOGRAM_FORMAT                                             0x8027
#endif //GL_HISTOGRAM_FORMAT
#ifndef GL_HISTOGRAM_RED_SIZE
#define GL_HISTOGRAM_RED_SIZE                                           0x8028
#endif //GL_HISTOGRAM_RED_SIZE
#ifndef GL_HISTOGRAM_GREEN_SIZE
#define GL_HISTOGRAM_GREEN_SIZE                                         0x8029
#endif //GL_HISTOGRAM_GREEN_SIZE
#ifndef GL_HISTOGRAM_BLUE_SIZE
#define GL_HISTOGRAM_BLUE_SIZE                                          0x802A
#endif //GL_HISTOGRAM_BLUE_SIZE
#ifndef GL_HISTOGRAM_ALPHA_SIZE
#define GL_HISTOGRAM_ALPHA_SIZE                                         0x802B
#endif //GL_HISTOGRAM_ALPHA_SIZE
#ifndef GL_HISTOGRAM_SINK
#define GL_HISTOGRAM_SINK                                               0x802D
#endif //GL_HISTOGRAM_SINK
#ifndef GL_MINMAX
#define GL_MINMAX                                                       0x802E
#endif //GL_MINMAX
#ifndef GL_MINMAX_FORMAT
#define GL_MINMAX_FORMAT                                                0x802F
#endif //GL_MINMAX_FORMAT
#ifndef GL_MINMAX_SINK
#define GL_MINMAX_SINK                                                  0x8030
#endif //GL_MINMAX_SINK
#ifndef GL_TABLE_TOO_LARGE
#define GL_TABLE_TOO_LARGE                                              0x8031
#endif //GL_TABLE_TOO_LARGE
#ifndef GL_UNSIGNED_BYTE_3_3_2
#define GL_UNSIGNED_BYTE_3_3_2                                          0x8032
#endif //GL_UNSIGNED_BYTE_3_3_2
#ifndef GL_UNSIGNED_SHORT_4_4_4_4
#define GL_UNSIGNED_SHORT_4_4_4_4                                       0x8033
#endif //GL_UNSIGNED_SHORT_4_4_4_4
#ifndef GL_UNSIGNED_SHORT_5_5_5_1
#define GL_UNSIGNED_SHORT_5_5_5_1                                       0x8034
#endif //GL_UNSIGNED_SHORT_5_5_5_1
#ifndef GL_UNSIGNED_INT_8_8_8_8
#define GL_UNSIGNED_INT_8_8_8_8                                         0x8035
#endif //GL_UNSIGNED_INT_8_8_8_8
#ifndef GL_UNSIGNED_INT_10_10_10_2
#define GL_UNSIGNED_INT_10_10_10_2                                      0x8036
#endif //GL_UNSIGNED_INT_10_10_10_2
#ifndef GL_RESCALE_NORMAL
#define GL_RESCALE_NORMAL                                               0x803A
#endif //GL_RESCALE_NORMAL
#ifndef GL_PACK_SKIP_IMAGES
#define GL_PACK_SKIP_IMAGES                                             0x806B
#endif //GL_PACK_SKIP_IMAGES
#ifndef GL_PACK_IMAGE_HEIGHT
#define GL_PACK_IMAGE_HEIGHT                                            0x806C
#endif //GL_PACK_IMAGE_HEIGHT
#ifndef GL_UNPACK_SKIP_IMAGES
#define GL_UNPACK_SKIP_IMAGES                                           0x806D
#endif //GL_UNPACK_SKIP_IMAGES
#ifndef GL_UNPACK_IMAGE_HEIGHT
#define GL_UNPACK_IMAGE_HEIGHT                                          0x806E
#endif //GL_UNPACK_IMAGE_HEIGHT
#ifndef GL_TEXTURE_3D
#define GL_TEXTURE_3D                                                   0x806F
#endif //GL_TEXTURE_3D
#ifndef GL_PROXY_TEXTURE_3D
#define GL_PROXY_TEXTURE_3D                                             0x8070
#endif //GL_PROXY_TEXTURE_3D
#ifndef GL_TEXTURE_DEPTH
#define GL_TEXTURE_DEPTH                                                0x8071
#endif //GL_TEXTURE_DEPTH
#ifndef GL_TEXTURE_WRAP_R
#define GL_TEXTURE_WRAP_R                                               0x8072
#endif //GL_TEXTURE_WRAP_R
#ifndef GL_MAX_3D_TEXTURE_SIZE
#define GL_MAX_3D_TEXTURE_SIZE                                          0x8073
#endif //GL_MAX_3D_TEXTURE_SIZE
#ifndef GL_COLOR_MATRIX
#define GL_COLOR_MATRIX                                                 0x80B1
#endif //GL_COLOR_MATRIX
#ifndef GL_COLOR_MATRIX_STACK_DEPTH
#define GL_COLOR_MATRIX_STACK_DEPTH                                     0x80B2
#endif //GL_COLOR_MATRIX_STACK_DEPTH
#ifndef GL_MAX_COLOR_MATRIX_STACK_DEPTH
#define GL_MAX_COLOR_MATRIX_STACK_DEPTH                                 0x80B3
#endif //GL_MAX_COLOR_MATRIX_STACK_DEPTH
#ifndef GL_POST_COLOR_MATRIX_RED_SCALE
#define GL_POST_COLOR_MATRIX_RED_SCALE                                  0x80B4
#endif //GL_POST_COLOR_MATRIX_RED_SCALE
#ifndef GL_POST_COLOR_MATRIX_GREEN_SCALE
#define GL_POST_COLOR_MATRIX_GREEN_SCALE                                0x80B5
#endif //GL_POST_COLOR_MATRIX_GREEN_SCALE
#ifndef GL_POST_COLOR_MATRIX_BLUE_SCALE
#define GL_POST_COLOR_MATRIX_BLUE_SCALE                                 0x80B6
#endif //GL_POST_COLOR_MATRIX_BLUE_SCALE
#ifndef GL_POST_COLOR_MATRIX_ALPHA_SCALE
#define GL_POST_COLOR_MATRIX_ALPHA_SCALE                                0x80B7
#endif //GL_POST_COLOR_MATRIX_ALPHA_SCALE
#ifndef GL_POST_COLOR_MATRIX_RED_BIAS
#define GL_POST_COLOR_MATRIX_RED_BIAS                                   0x80B8
#endif //GL_POST_COLOR_MATRIX_RED_BIAS
#ifndef GL_POST_COLOR_MATRIX_GREEN_BIAS
#define GL_POST_COLOR_MATRIX_GREEN_BIAS                                 0x80B9
#endif //GL_POST_COLOR_MATRIX_GREEN_BIAS
#ifndef GL_POST_COLOR_MATRIX_BLUE_BIAS
#define GL_POST_COLOR_MATRIX_BLUE_BIAS                                  0x80BA
#endif //GL_POST_COLOR_MATRIX_BLUE_BIAS
#ifndef GL_POST_COLOR_MATRIX_ALPHA_BIAS
#define GL_POST_COLOR_MATRIX_ALPHA_BIAS                                 0x80BB
#endif //GL_POST_COLOR_MATRIX_ALPHA_BIAS
#ifndef GL_COLOR_TABLE
#define GL_COLOR_TABLE                                                  0x80D0
#endif //GL_COLOR_TABLE
#ifndef GL_POST_CONVOLUTION_COLOR_TABLE
#define GL_POST_CONVOLUTION_COLOR_TABLE                                 0x80D1
#endif //GL_POST_CONVOLUTION_COLOR_TABLE
#ifndef GL_POST_COLOR_MATRIX_COLOR_TABLE
#define GL_POST_COLOR_MATRIX_COLOR_TABLE                                0x80D2
#endif //GL_POST_COLOR_MATRIX_COLOR_TABLE
#ifndef GL_PROXY_COLOR_TABLE
#define GL_PROXY_COLOR_TABLE                                            0x80D3
#endif //GL_PROXY_COLOR_TABLE
#ifndef GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE                           0x80D4
#endif //GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
#ifndef GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE                          0x80D5
#endif //GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
#ifndef GL_COLOR_TABLE_SCALE
#define GL_COLOR_TABLE_SCALE                                            0x80D6
#endif //GL_COLOR_TABLE_SCALE
#ifndef GL_COLOR_TABLE_BIAS
#define GL_COLOR_TABLE_BIAS                                             0x80D7
#endif //GL_COLOR_TABLE_BIAS
#ifndef GL_COLOR_TABLE_FORMAT
#define GL_COLOR_TABLE_FORMAT                                           0x80D8
#endif //GL_COLOR_TABLE_FORMAT
#ifndef GL_COLOR_TABLE_WIDTH
#define GL_COLOR_TABLE_WIDTH                                            0x80D9
#endif //GL_COLOR_TABLE_WIDTH
#ifndef GL_COLOR_TABLE_RED_SIZE
#define GL_COLOR_TABLE_RED_SIZE                                         0x80DA
#endif //GL_COLOR_TABLE_RED_SIZE
#ifndef GL_COLOR_TABLE_GREEN_SIZE
#define GL_COLOR_TABLE_GREEN_SIZE                                       0x80DB
#endif //GL_COLOR_TABLE_GREEN_SIZE
#ifndef GL_COLOR_TABLE_BLUE_SIZE
#define GL_COLOR_TABLE_BLUE_SIZE                                        0x80DC
#endif //GL_COLOR_TABLE_BLUE_SIZE
#ifndef GL_COLOR_TABLE_ALPHA_SIZE
#define GL_COLOR_TABLE_ALPHA_SIZE                                       0x80DD
#endif //GL_COLOR_TABLE_ALPHA_SIZE
#ifndef GL_COLOR_TABLE_LUMINANCE_SIZE
#define GL_COLOR_TABLE_LUMINANCE_SIZE                                   0x80DE
#endif //GL_COLOR_TABLE_LUMINANCE_SIZE
#ifndef GL_COLOR_TABLE_INTENSITY_SIZE
#define GL_COLOR_TABLE_INTENSITY_SIZE                                   0x80DF
#endif //GL_COLOR_TABLE_INTENSITY_SIZE
#ifndef GL_BGR
#define GL_BGR                                                          0x80E0
#endif //GL_BGR
#ifndef GL_BGRA
#define GL_BGRA                                                         0x80E1
#endif //GL_BGRA
#ifndef GL_MAX_ELEMENTS_VERTICES
#define GL_MAX_ELEMENTS_VERTICES                                        0x80E8
#endif //GL_MAX_ELEMENTS_VERTICES
#ifndef GL_MAX_ELEMENTS_INDICES
#define GL_MAX_ELEMENTS_INDICES                                         0x80E9
#endif //GL_MAX_ELEMENTS_INDICES
#ifndef GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE                                                0x812F
#endif //GL_CLAMP_TO_EDGE
#ifndef GL_TEXTURE_MIN_LOD
#define GL_TEXTURE_MIN_LOD                                              0x813A
#endif //GL_TEXTURE_MIN_LOD
#ifndef GL_TEXTURE_MAX_LOD
#define GL_TEXTURE_MAX_LOD                                              0x813B
#endif //GL_TEXTURE_MAX_LOD
#ifndef GL_TEXTURE_BASE_LEVEL
#define GL_TEXTURE_BASE_LEVEL                                           0x813C
#endif //GL_TEXTURE_BASE_LEVEL
#ifndef GL_TEXTURE_MAX_LEVEL
#define GL_TEXTURE_MAX_LEVEL                                            0x813D
#endif //GL_TEXTURE_MAX_LEVEL
#ifndef GL_CONSTANT_BORDER
#define GL_CONSTANT_BORDER                                              0x8151
#endif //GL_CONSTANT_BORDER
#ifndef GL_REPLICATE_BORDER
#define GL_REPLICATE_BORDER                                             0x8153
#endif //GL_REPLICATE_BORDER
#ifndef GL_CONVOLUTION_BORDER_COLOR
#define GL_CONVOLUTION_BORDER_COLOR                                     0x8154
#endif //GL_CONVOLUTION_BORDER_COLOR
#ifndef GL_LIGHT_MODEL_COLOR_CONTROL
#define GL_LIGHT_MODEL_COLOR_CONTROL                                    0x81F8
#endif //GL_LIGHT_MODEL_COLOR_CONTROL
#ifndef GL_SINGLE_COLOR
#define GL_SINGLE_COLOR                                                 0x81F9
#endif //GL_SINGLE_COLOR
#ifndef GL_SEPARATE_SPECULAR_COLOR
#define GL_SEPARATE_SPECULAR_COLOR                                      0x81FA
#endif //GL_SEPARATE_SPECULAR_COLOR
#ifndef GL_UNSIGNED_BYTE_2_3_3_REV
#define GL_UNSIGNED_BYTE_2_3_3_REV                                      0x8362
#endif //GL_UNSIGNED_BYTE_2_3_3_REV
#ifndef GL_UNSIGNED_SHORT_5_6_5
#define GL_UNSIGNED_SHORT_5_6_5                                         0x8363
#endif //GL_UNSIGNED_SHORT_5_6_5
#ifndef GL_UNSIGNED_SHORT_5_6_5_REV
#define GL_UNSIGNED_SHORT_5_6_5_REV                                     0x8364
#endif //GL_UNSIGNED_SHORT_5_6_5_REV
#ifndef GL_UNSIGNED_SHORT_4_4_4_4_REV
#define GL_UNSIGNED_SHORT_4_4_4_4_REV                                   0x8365
#endif //GL_UNSIGNED_SHORT_4_4_4_4_REV
#ifndef GL_UNSIGNED_SHORT_1_5_5_5_REV
#define GL_UNSIGNED_SHORT_1_5_5_5_REV                                   0x8366
#endif //GL_UNSIGNED_SHORT_1_5_5_5_REV
#ifndef GL_UNSIGNED_INT_8_8_8_8_REV
#define GL_UNSIGNED_INT_8_8_8_8_REV                                     0x8367
#endif //GL_UNSIGNED_INT_8_8_8_8_REV
#ifndef GL_UNSIGNED_INT_2_10_10_10_REV
#define GL_UNSIGNED_INT_2_10_10_10_REV                                  0x8368
#endif //GL_UNSIGNED_INT_2_10_10_10_REV
#ifndef GL_ALIASED_POINT_SIZE_RANGE
#define GL_ALIASED_POINT_SIZE_RANGE                                     0x846D
#endif //GL_ALIASED_POINT_SIZE_RANGE
#ifndef GL_ALIASED_LINE_WIDTH_RANGE
#define GL_ALIASED_LINE_WIDTH_RANGE                                     0x846E
#endif //GL_ALIASED_LINE_WIDTH_RANGE

#endif //GL_VERSION_1_2


typedef void (*PFNBLENDCOLORPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);

static inline void BlendColor(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)
{
	static PFNBLENDCOLORPROC_HPP fn=reinterpret_cast<PFNBLENDCOLORPROC_HPP>(_impl::_get_proc_address("glBlendColor",1,2));
	 fn(red,green,blue,alpha);
}

typedef void (*PFNBLENDEQUATIONPROC_HPP)(GLenum mode);

static inline void BlendEquation(GLenum mode)
{
	static PFNBLENDEQUATIONPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONPROC_HPP>(_impl::_get_proc_address("glBlendEquation",1,2));
	 fn(mode);
}

typedef void (*PFNDRAWRANGEELEMENTSPROC_HPP)(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices);

static inline void DrawRangeElements(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices)
{
	static PFNDRAWRANGEELEMENTSPROC_HPP fn=reinterpret_cast<PFNDRAWRANGEELEMENTSPROC_HPP>(_impl::_get_proc_address("glDrawRangeElements",1,2));
	 fn(mode,start,end,count,type,indices);
}

typedef void (*PFNTEXIMAGE3DPROC_HPP)(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexImage3D(GLenum target,GLint level,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXIMAGE3DPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE3DPROC_HPP>(_impl::_get_proc_address("glTexImage3D",1,2));
	 fn(target,level,internalformat,width,height,depth,border,format,type,pixels);
}

typedef void (*PFNTEXSUBIMAGE3DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXSUBIMAGE3DPROC_HPP fn=reinterpret_cast<PFNTEXSUBIMAGE3DPROC_HPP>(_impl::_get_proc_address("glTexSubImage3D",1,2));
	 fn(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
}

typedef void (*PFNCOPYTEXSUBIMAGE3DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYTEXSUBIMAGE3DPROC_HPP fn=reinterpret_cast<PFNCOPYTEXSUBIMAGE3DPROC_HPP>(_impl::_get_proc_address("glCopyTexSubImage3D",1,2));
	 fn(target,level,xoffset,yoffset,zoffset,x,y,width,height);
}

typedef void (*PFNCOLORTABLEPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *table);

static inline void ColorTable(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *table)
{
	static PFNCOLORTABLEPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEPROC_HPP>(_impl::_get_proc_address("glColorTable",1,2));
	 fn(target,internalformat,width,format,type,table);
}

typedef void (*PFNCOLORTABLEPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void ColorTableParameterfv(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNCOLORTABLEPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glColorTableParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCOLORTABLEPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void ColorTableParameteriv(GLenum target,GLenum pname,const GLint *params)
{
	static PFNCOLORTABLEPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glColorTableParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCOPYCOLORTABLEPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);

static inline void CopyColorTable(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCOLORTABLEPROC_HPP fn=reinterpret_cast<PFNCOPYCOLORTABLEPROC_HPP>(_impl::_get_proc_address("glCopyColorTable",1,2));
	 fn(target,internalformat,x,y,width);
}

typedef void (*PFNGETCOLORTABLEPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *table);

static inline void GetColorTable(GLenum target,GLenum format,GLenum type,GLvoid *table)
{
	static PFNGETCOLORTABLEPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPROC_HPP>(_impl::_get_proc_address("glGetColorTable",1,2));
	 fn(target,format,type,table);
}

typedef void (*PFNGETCOLORTABLEPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetColorTableParameterfv(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETCOLORTABLEPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETCOLORTABLEPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetColorTableParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETCOLORTABLEPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCOLORSUBTABLEPROC_HPP)(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const GLvoid *data);

static inline void ColorSubTable(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const GLvoid *data)
{
	static PFNCOLORSUBTABLEPROC_HPP fn=reinterpret_cast<PFNCOLORSUBTABLEPROC_HPP>(_impl::_get_proc_address("glColorSubTable",1,2));
	 fn(target,start,count,format,type,data);
}

typedef void (*PFNCOPYCOLORSUBTABLEPROC_HPP)(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width);

static inline void CopyColorSubTable(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCOLORSUBTABLEPROC_HPP fn=reinterpret_cast<PFNCOPYCOLORSUBTABLEPROC_HPP>(_impl::_get_proc_address("glCopyColorSubTable",1,2));
	 fn(target,start,x,y,width);
}

typedef void (*PFNCONVOLUTIONFILTER1DPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *image);

static inline void ConvolutionFilter1D(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *image)
{
	static PFNCONVOLUTIONFILTER1DPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONFILTER1DPROC_HPP>(_impl::_get_proc_address("glConvolutionFilter1D",1,2));
	 fn(target,internalformat,width,format,type,image);
}

typedef void (*PFNCONVOLUTIONFILTER2DPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *image);

static inline void ConvolutionFilter2D(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *image)
{
	static PFNCONVOLUTIONFILTER2DPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONFILTER2DPROC_HPP>(_impl::_get_proc_address("glConvolutionFilter2D",1,2));
	 fn(target,internalformat,width,height,format,type,image);
}

typedef void (*PFNCONVOLUTIONPARAMETERFPROC_HPP)(GLenum target,GLenum pname,GLfloat params);

static inline void ConvolutionParameterf(GLenum target,GLenum pname,GLfloat params)
{
	static PFNCONVOLUTIONPARAMETERFPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERFPROC_HPP>(_impl::_get_proc_address("glConvolutionParameterf",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void ConvolutionParameterfv(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNCONVOLUTIONPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glConvolutionParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERIPROC_HPP)(GLenum target,GLenum pname,GLint params);

static inline void ConvolutionParameteri(GLenum target,GLenum pname,GLint params)
{
	static PFNCONVOLUTIONPARAMETERIPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERIPROC_HPP>(_impl::_get_proc_address("glConvolutionParameteri",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void ConvolutionParameteriv(GLenum target,GLenum pname,const GLint *params)
{
	static PFNCONVOLUTIONPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glConvolutionParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNCOPYCONVOLUTIONFILTER1DPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);

static inline void CopyConvolutionFilter1D(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCONVOLUTIONFILTER1DPROC_HPP fn=reinterpret_cast<PFNCOPYCONVOLUTIONFILTER1DPROC_HPP>(_impl::_get_proc_address("glCopyConvolutionFilter1D",1,2));
	 fn(target,internalformat,x,y,width);
}

typedef void (*PFNCOPYCONVOLUTIONFILTER2DPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyConvolutionFilter2D(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYCONVOLUTIONFILTER2DPROC_HPP fn=reinterpret_cast<PFNCOPYCONVOLUTIONFILTER2DPROC_HPP>(_impl::_get_proc_address("glCopyConvolutionFilter2D",1,2));
	 fn(target,internalformat,x,y,width,height);
}

typedef void (*PFNGETCONVOLUTIONFILTERPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *image);

static inline void GetConvolutionFilter(GLenum target,GLenum format,GLenum type,GLvoid *image)
{
	static PFNGETCONVOLUTIONFILTERPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONFILTERPROC_HPP>(_impl::_get_proc_address("glGetConvolutionFilter",1,2));
	 fn(target,format,type,image);
}

typedef void (*PFNGETCONVOLUTIONPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetConvolutionParameterfv(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETCONVOLUTIONPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glGetConvolutionParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETCONVOLUTIONPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetConvolutionParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETCONVOLUTIONPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetConvolutionParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETSEPARABLEFILTERPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *row,GLvoid *column,GLvoid *span);

static inline void GetSeparableFilter(GLenum target,GLenum format,GLenum type,GLvoid *row,GLvoid *column,GLvoid *span)
{
	static PFNGETSEPARABLEFILTERPROC_HPP fn=reinterpret_cast<PFNGETSEPARABLEFILTERPROC_HPP>(_impl::_get_proc_address("glGetSeparableFilter",1,2));
	 fn(target,format,type,row,column,span);
}

typedef void (*PFNSEPARABLEFILTER2DPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *row,const GLvoid *column);

static inline void SeparableFilter2D(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *row,const GLvoid *column)
{
	static PFNSEPARABLEFILTER2DPROC_HPP fn=reinterpret_cast<PFNSEPARABLEFILTER2DPROC_HPP>(_impl::_get_proc_address("glSeparableFilter2D",1,2));
	 fn(target,internalformat,width,height,format,type,row,column);
}

typedef void (*PFNGETHISTOGRAMPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values);

static inline void GetHistogram(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values)
{
	static PFNGETHISTOGRAMPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMPROC_HPP>(_impl::_get_proc_address("glGetHistogram",1,2));
	 fn(target,reset,format,type,values);
}

typedef void (*PFNGETHISTOGRAMPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetHistogramParameterfv(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETHISTOGRAMPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glGetHistogramParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETHISTOGRAMPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetHistogramParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETHISTOGRAMPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetHistogramParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETMINMAXPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values);

static inline void GetMinmax(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values)
{
	static PFNGETMINMAXPROC_HPP fn=reinterpret_cast<PFNGETMINMAXPROC_HPP>(_impl::_get_proc_address("glGetMinmax",1,2));
	 fn(target,reset,format,type,values);
}

typedef void (*PFNGETMINMAXPARAMETERFVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetMinmaxParameterfv(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETMINMAXPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNGETMINMAXPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glGetMinmaxParameterfv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNGETMINMAXPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetMinmaxParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMINMAXPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETMINMAXPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetMinmaxParameteriv",1,2));
	 fn(target,pname,params);
}

typedef void (*PFNHISTOGRAMPROC_HPP)(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink);

static inline void Histogram(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink)
{
	static PFNHISTOGRAMPROC_HPP fn=reinterpret_cast<PFNHISTOGRAMPROC_HPP>(_impl::_get_proc_address("glHistogram",1,2));
	 fn(target,width,internalformat,sink);
}

typedef void (*PFNMINMAXPROC_HPP)(GLenum target,GLenum internalformat,GLboolean sink);

static inline void Minmax(GLenum target,GLenum internalformat,GLboolean sink)
{
	static PFNMINMAXPROC_HPP fn=reinterpret_cast<PFNMINMAXPROC_HPP>(_impl::_get_proc_address("glMinmax",1,2));
	 fn(target,internalformat,sink);
}

typedef void (*PFNRESETHISTOGRAMPROC_HPP)(GLenum target);

static inline void ResetHistogram(GLenum target)
{
	static PFNRESETHISTOGRAMPROC_HPP fn=reinterpret_cast<PFNRESETHISTOGRAMPROC_HPP>(_impl::_get_proc_address("glResetHistogram",1,2));
	 fn(target);
}

typedef void (*PFNRESETMINMAXPROC_HPP)(GLenum target);

static inline void ResetMinmax(GLenum target)
{
	static PFNRESETMINMAXPROC_HPP fn=reinterpret_cast<PFNRESETMINMAXPROC_HPP>(_impl::_get_proc_address("glResetMinmax",1,2));
	 fn(target);
}
#endif //(GLPROC_VERSION >= 12)
#if (GLPROC_VERSION >= 13)

#ifndef GL_VERSION_1_3

#define GL_VERSION_1_3
#ifndef GL_MULTISAMPLE_BIT
#define GL_MULTISAMPLE_BIT                                              0x20000000
#endif //GL_MULTISAMPLE_BIT
#ifndef GL_MULTISAMPLE
#define GL_MULTISAMPLE                                                  0x809D
#endif //GL_MULTISAMPLE
#ifndef GL_SAMPLE_ALPHA_TO_COVERAGE
#define GL_SAMPLE_ALPHA_TO_COVERAGE                                     0x809E
#endif //GL_SAMPLE_ALPHA_TO_COVERAGE
#ifndef GL_SAMPLE_ALPHA_TO_ONE
#define GL_SAMPLE_ALPHA_TO_ONE                                          0x809F
#endif //GL_SAMPLE_ALPHA_TO_ONE
#ifndef GL_SAMPLE_COVERAGE
#define GL_SAMPLE_COVERAGE                                              0x80A0
#endif //GL_SAMPLE_COVERAGE
#ifndef GL_SAMPLE_BUFFERS
#define GL_SAMPLE_BUFFERS                                               0x80A8
#endif //GL_SAMPLE_BUFFERS
#ifndef GL_SAMPLES
#define GL_SAMPLES                                                      0x80A9
#endif //GL_SAMPLES
#ifndef GL_SAMPLE_COVERAGE_VALUE
#define GL_SAMPLE_COVERAGE_VALUE                                        0x80AA
#endif //GL_SAMPLE_COVERAGE_VALUE
#ifndef GL_SAMPLE_COVERAGE_INVERT
#define GL_SAMPLE_COVERAGE_INVERT                                       0x80AB
#endif //GL_SAMPLE_COVERAGE_INVERT
#ifndef GL_CLAMP_TO_BORDER
#define GL_CLAMP_TO_BORDER                                              0x812D
#endif //GL_CLAMP_TO_BORDER
#ifndef GL_TEXTURE0
#define GL_TEXTURE0                                                     0x84C0
#endif //GL_TEXTURE0
#ifndef GL_TEXTURE1
#define GL_TEXTURE1                                                     0x84C1
#endif //GL_TEXTURE1
#ifndef GL_TEXTURE2
#define GL_TEXTURE2                                                     0x84C2
#endif //GL_TEXTURE2
#ifndef GL_TEXTURE3
#define GL_TEXTURE3                                                     0x84C3
#endif //GL_TEXTURE3
#ifndef GL_TEXTURE4
#define GL_TEXTURE4                                                     0x84C4
#endif //GL_TEXTURE4
#ifndef GL_TEXTURE5
#define GL_TEXTURE5                                                     0x84C5
#endif //GL_TEXTURE5
#ifndef GL_TEXTURE6
#define GL_TEXTURE6                                                     0x84C6
#endif //GL_TEXTURE6
#ifndef GL_TEXTURE7
#define GL_TEXTURE7                                                     0x84C7
#endif //GL_TEXTURE7
#ifndef GL_TEXTURE8
#define GL_TEXTURE8                                                     0x84C8
#endif //GL_TEXTURE8
#ifndef GL_TEXTURE9
#define GL_TEXTURE9                                                     0x84C9
#endif //GL_TEXTURE9
#ifndef GL_TEXTURE10
#define GL_TEXTURE10                                                    0x84CA
#endif //GL_TEXTURE10
#ifndef GL_TEXTURE11
#define GL_TEXTURE11                                                    0x84CB
#endif //GL_TEXTURE11
#ifndef GL_TEXTURE12
#define GL_TEXTURE12                                                    0x84CC
#endif //GL_TEXTURE12
#ifndef GL_TEXTURE13
#define GL_TEXTURE13                                                    0x84CD
#endif //GL_TEXTURE13
#ifndef GL_TEXTURE14
#define GL_TEXTURE14                                                    0x84CE
#endif //GL_TEXTURE14
#ifndef GL_TEXTURE15
#define GL_TEXTURE15                                                    0x84CF
#endif //GL_TEXTURE15
#ifndef GL_TEXTURE16
#define GL_TEXTURE16                                                    0x84D0
#endif //GL_TEXTURE16
#ifndef GL_TEXTURE17
#define GL_TEXTURE17                                                    0x84D1
#endif //GL_TEXTURE17
#ifndef GL_TEXTURE18
#define GL_TEXTURE18                                                    0x84D2
#endif //GL_TEXTURE18
#ifndef GL_TEXTURE19
#define GL_TEXTURE19                                                    0x84D3
#endif //GL_TEXTURE19
#ifndef GL_TEXTURE20
#define GL_TEXTURE20                                                    0x84D4
#endif //GL_TEXTURE20
#ifndef GL_TEXTURE21
#define GL_TEXTURE21                                                    0x84D5
#endif //GL_TEXTURE21
#ifndef GL_TEXTURE22
#define GL_TEXTURE22                                                    0x84D6
#endif //GL_TEXTURE22
#ifndef GL_TEXTURE23
#define GL_TEXTURE23                                                    0x84D7
#endif //GL_TEXTURE23
#ifndef GL_TEXTURE24
#define GL_TEXTURE24                                                    0x84D8
#endif //GL_TEXTURE24
#ifndef GL_TEXTURE25
#define GL_TEXTURE25                                                    0x84D9
#endif //GL_TEXTURE25
#ifndef GL_TEXTURE26
#define GL_TEXTURE26                                                    0x84DA
#endif //GL_TEXTURE26
#ifndef GL_TEXTURE27
#define GL_TEXTURE27                                                    0x84DB
#endif //GL_TEXTURE27
#ifndef GL_TEXTURE28
#define GL_TEXTURE28                                                    0x84DC
#endif //GL_TEXTURE28
#ifndef GL_TEXTURE29
#define GL_TEXTURE29                                                    0x84DD
#endif //GL_TEXTURE29
#ifndef GL_TEXTURE30
#define GL_TEXTURE30                                                    0x84DE
#endif //GL_TEXTURE30
#ifndef GL_TEXTURE31
#define GL_TEXTURE31                                                    0x84DF
#endif //GL_TEXTURE31
#ifndef GL_ACTIVE_TEXTURE
#define GL_ACTIVE_TEXTURE                                               0x84E0
#endif //GL_ACTIVE_TEXTURE
#ifndef GL_CLIENT_ACTIVE_TEXTURE
#define GL_CLIENT_ACTIVE_TEXTURE                                        0x84E1
#endif //GL_CLIENT_ACTIVE_TEXTURE
#ifndef GL_MAX_TEXTURE_UNITS
#define GL_MAX_TEXTURE_UNITS                                            0x84E2
#endif //GL_MAX_TEXTURE_UNITS
#ifndef GL_TRANSPOSE_MODELVIEW_MATRIX
#define GL_TRANSPOSE_MODELVIEW_MATRIX                                   0x84E3
#endif //GL_TRANSPOSE_MODELVIEW_MATRIX
#ifndef GL_TRANSPOSE_PROJECTION_MATRIX
#define GL_TRANSPOSE_PROJECTION_MATRIX                                  0x84E4
#endif //GL_TRANSPOSE_PROJECTION_MATRIX
#ifndef GL_TRANSPOSE_TEXTURE_MATRIX
#define GL_TRANSPOSE_TEXTURE_MATRIX                                     0x84E5
#endif //GL_TRANSPOSE_TEXTURE_MATRIX
#ifndef GL_TRANSPOSE_COLOR_MATRIX
#define GL_TRANSPOSE_COLOR_MATRIX                                       0x84E6
#endif //GL_TRANSPOSE_COLOR_MATRIX
#ifndef GL_SUBTRACT
#define GL_SUBTRACT                                                     0x84E7
#endif //GL_SUBTRACT
#ifndef GL_COMPRESSED_ALPHA
#define GL_COMPRESSED_ALPHA                                             0x84E9
#endif //GL_COMPRESSED_ALPHA
#ifndef GL_COMPRESSED_LUMINANCE
#define GL_COMPRESSED_LUMINANCE                                         0x84EA
#endif //GL_COMPRESSED_LUMINANCE
#ifndef GL_COMPRESSED_LUMINANCE_ALPHA
#define GL_COMPRESSED_LUMINANCE_ALPHA                                   0x84EB
#endif //GL_COMPRESSED_LUMINANCE_ALPHA
#ifndef GL_COMPRESSED_INTENSITY
#define GL_COMPRESSED_INTENSITY                                         0x84EC
#endif //GL_COMPRESSED_INTENSITY
#ifndef GL_COMPRESSED_RGB
#define GL_COMPRESSED_RGB                                               0x84ED
#endif //GL_COMPRESSED_RGB
#ifndef GL_COMPRESSED_RGBA
#define GL_COMPRESSED_RGBA                                              0x84EE
#endif //GL_COMPRESSED_RGBA
#ifndef GL_TEXTURE_COMPRESSION_HINT
#define GL_TEXTURE_COMPRESSION_HINT                                     0x84EF
#endif //GL_TEXTURE_COMPRESSION_HINT
#ifndef GL_NORMAL_MAP
#define GL_NORMAL_MAP                                                   0x8511
#endif //GL_NORMAL_MAP
#ifndef GL_REFLECTION_MAP
#define GL_REFLECTION_MAP                                               0x8512
#endif //GL_REFLECTION_MAP
#ifndef GL_TEXTURE_CUBE_MAP
#define GL_TEXTURE_CUBE_MAP                                             0x8513
#endif //GL_TEXTURE_CUBE_MAP
#ifndef GL_TEXTURE_BINDING_CUBE_MAP
#define GL_TEXTURE_BINDING_CUBE_MAP                                     0x8514
#endif //GL_TEXTURE_BINDING_CUBE_MAP
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_X
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X                                  0x8515
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_X
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_X
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X                                  0x8516
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_X
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Y
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y                                  0x8517
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Y
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y                                  0x8518
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Z
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z                                  0x8519
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Z
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z                                  0x851A
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
#ifndef GL_PROXY_TEXTURE_CUBE_MAP
#define GL_PROXY_TEXTURE_CUBE_MAP                                       0x851B
#endif //GL_PROXY_TEXTURE_CUBE_MAP
#ifndef GL_MAX_CUBE_MAP_TEXTURE_SIZE
#define GL_MAX_CUBE_MAP_TEXTURE_SIZE                                    0x851C
#endif //GL_MAX_CUBE_MAP_TEXTURE_SIZE
#ifndef GL_COMBINE
#define GL_COMBINE                                                      0x8570
#endif //GL_COMBINE
#ifndef GL_COMBINE_RGB
#define GL_COMBINE_RGB                                                  0x8571
#endif //GL_COMBINE_RGB
#ifndef GL_COMBINE_ALPHA
#define GL_COMBINE_ALPHA                                                0x8572
#endif //GL_COMBINE_ALPHA
#ifndef GL_RGB_SCALE
#define GL_RGB_SCALE                                                    0x8573
#endif //GL_RGB_SCALE
#ifndef GL_ADD_SIGNED
#define GL_ADD_SIGNED                                                   0x8574
#endif //GL_ADD_SIGNED
#ifndef GL_INTERPOLATE
#define GL_INTERPOLATE                                                  0x8575
#endif //GL_INTERPOLATE
#ifndef GL_CONSTANT
#define GL_CONSTANT                                                     0x8576
#endif //GL_CONSTANT
#ifndef GL_PRIMARY_COLOR
#define GL_PRIMARY_COLOR                                                0x8577
#endif //GL_PRIMARY_COLOR
#ifndef GL_PREVIOUS
#define GL_PREVIOUS                                                     0x8578
#endif //GL_PREVIOUS
#ifndef GL_SOURCE0_RGB
#define GL_SOURCE0_RGB                                                  0x8580
#endif //GL_SOURCE0_RGB
#ifndef GL_SOURCE1_RGB
#define GL_SOURCE1_RGB                                                  0x8581
#endif //GL_SOURCE1_RGB
#ifndef GL_SOURCE2_RGB
#define GL_SOURCE2_RGB                                                  0x8582
#endif //GL_SOURCE2_RGB
#ifndef GL_SOURCE0_ALPHA
#define GL_SOURCE0_ALPHA                                                0x8588
#endif //GL_SOURCE0_ALPHA
#ifndef GL_SOURCE1_ALPHA
#define GL_SOURCE1_ALPHA                                                0x8589
#endif //GL_SOURCE1_ALPHA
#ifndef GL_SOURCE2_ALPHA
#define GL_SOURCE2_ALPHA                                                0x858A
#endif //GL_SOURCE2_ALPHA
#ifndef GL_OPERAND0_RGB
#define GL_OPERAND0_RGB                                                 0x8590
#endif //GL_OPERAND0_RGB
#ifndef GL_OPERAND1_RGB
#define GL_OPERAND1_RGB                                                 0x8591
#endif //GL_OPERAND1_RGB
#ifndef GL_OPERAND2_RGB
#define GL_OPERAND2_RGB                                                 0x8592
#endif //GL_OPERAND2_RGB
#ifndef GL_OPERAND0_ALPHA
#define GL_OPERAND0_ALPHA                                               0x8598
#endif //GL_OPERAND0_ALPHA
#ifndef GL_OPERAND1_ALPHA
#define GL_OPERAND1_ALPHA                                               0x8599
#endif //GL_OPERAND1_ALPHA
#ifndef GL_OPERAND2_ALPHA
#define GL_OPERAND2_ALPHA                                               0x859A
#endif //GL_OPERAND2_ALPHA
#ifndef GL_TEXTURE_COMPRESSED_IMAGE_SIZE
#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE                                0x86A0
#endif //GL_TEXTURE_COMPRESSED_IMAGE_SIZE
#ifndef GL_TEXTURE_COMPRESSED
#define GL_TEXTURE_COMPRESSED                                           0x86A1
#endif //GL_TEXTURE_COMPRESSED
#ifndef GL_NUM_COMPRESSED_TEXTURE_FORMATS
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS                               0x86A2
#endif //GL_NUM_COMPRESSED_TEXTURE_FORMATS
#ifndef GL_COMPRESSED_TEXTURE_FORMATS
#define GL_COMPRESSED_TEXTURE_FORMATS                                   0x86A3
#endif //GL_COMPRESSED_TEXTURE_FORMATS
#ifndef GL_DOT3_RGB
#define GL_DOT3_RGB                                                     0x86AE
#endif //GL_DOT3_RGB
#ifndef GL_DOT3_RGBA
#define GL_DOT3_RGBA                                                    0x86AF
#endif //GL_DOT3_RGBA

#endif //GL_VERSION_1_3


typedef void (*PFNACTIVETEXTUREPROC_HPP)(GLenum texture);

static inline void ActiveTexture(GLenum texture)
{
	static PFNACTIVETEXTUREPROC_HPP fn=reinterpret_cast<PFNACTIVETEXTUREPROC_HPP>(_impl::_get_proc_address("glActiveTexture",1,3));
	 fn(texture);
}

typedef void (*PFNSAMPLECOVERAGEPROC_HPP)(GLfloat value,GLboolean invert);

static inline void SampleCoverage(GLfloat value,GLboolean invert)
{
	static PFNSAMPLECOVERAGEPROC_HPP fn=reinterpret_cast<PFNSAMPLECOVERAGEPROC_HPP>(_impl::_get_proc_address("glSampleCoverage",1,3));
	 fn(value,invert);
}

typedef void (*PFNCOMPRESSEDTEXIMAGE3DPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage3D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE3DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE3DPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage3D",1,3));
	 fn(target,level,internalformat,width,height,depth,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXIMAGE2DPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage2D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE2DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE2DPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage2D",1,3));
	 fn(target,level,internalformat,width,height,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXIMAGE1DPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage1D(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE1DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE1DPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage1D",1,3));
	 fn(target,level,internalformat,width,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE3DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE3DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE3DPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage3D",1,3));
	 fn(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE2DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE2DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE2DPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage2D",1,3));
	 fn(target,level,xoffset,yoffset,width,height,format,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE1DPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE1DPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE1DPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage1D",1,3));
	 fn(target,level,xoffset,width,format,imageSize,data);
}

typedef void (*PFNGETCOMPRESSEDTEXIMAGEPROC_HPP)(GLenum target,GLint level,GLvoid *img);

static inline void GetCompressedTexImage(GLenum target,GLint level,GLvoid *img)
{
	static PFNGETCOMPRESSEDTEXIMAGEPROC_HPP fn=reinterpret_cast<PFNGETCOMPRESSEDTEXIMAGEPROC_HPP>(_impl::_get_proc_address("glGetCompressedTexImage",1,3));
	 fn(target,level,img);
}

typedef void (*PFNCLIENTACTIVETEXTUREPROC_HPP)(GLenum texture);

static inline void ClientActiveTexture(GLenum texture)
{
	static PFNCLIENTACTIVETEXTUREPROC_HPP fn=reinterpret_cast<PFNCLIENTACTIVETEXTUREPROC_HPP>(_impl::_get_proc_address("glClientActiveTexture",1,3));
	 fn(texture);
}

typedef void (*PFNMULTITEXCOORD1DPROC_HPP)(GLenum target,GLdouble s);

static inline void MultiTexCoord1d(GLenum target,GLdouble s)
{
	static PFNMULTITEXCOORD1DPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1DPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1d",1,3));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1DVPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord1dv(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD1DVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1DVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1dv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1FPROC_HPP)(GLenum target,GLfloat s);

static inline void MultiTexCoord1f(GLenum target,GLfloat s)
{
	static PFNMULTITEXCOORD1FPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1FPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1f",1,3));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1FVPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord1fv(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD1FVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1FVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1fv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1IPROC_HPP)(GLenum target,GLint s);

static inline void MultiTexCoord1i(GLenum target,GLint s)
{
	static PFNMULTITEXCOORD1IPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1IPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1i",1,3));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1IVPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord1iv(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD1IVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1IVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1iv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1SPROC_HPP)(GLenum target,GLshort s);

static inline void MultiTexCoord1s(GLenum target,GLshort s)
{
	static PFNMULTITEXCOORD1SPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1SPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1s",1,3));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1SVPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord1sv(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD1SVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1SVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1sv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2DPROC_HPP)(GLenum target,GLdouble s,GLdouble t);

static inline void MultiTexCoord2d(GLenum target,GLdouble s,GLdouble t)
{
	static PFNMULTITEXCOORD2DPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2DPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2d",1,3));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2DVPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord2dv(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD2DVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2DVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2dv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2FPROC_HPP)(GLenum target,GLfloat s,GLfloat t);

static inline void MultiTexCoord2f(GLenum target,GLfloat s,GLfloat t)
{
	static PFNMULTITEXCOORD2FPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2FPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2f",1,3));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2FVPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord2fv(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD2FVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2FVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2fv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2IPROC_HPP)(GLenum target,GLint s,GLint t);

static inline void MultiTexCoord2i(GLenum target,GLint s,GLint t)
{
	static PFNMULTITEXCOORD2IPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2IPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2i",1,3));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2IVPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord2iv(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD2IVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2IVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2iv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2SPROC_HPP)(GLenum target,GLshort s,GLshort t);

static inline void MultiTexCoord2s(GLenum target,GLshort s,GLshort t)
{
	static PFNMULTITEXCOORD2SPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2SPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2s",1,3));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2SVPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord2sv(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD2SVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2SVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2sv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3DPROC_HPP)(GLenum target,GLdouble s,GLdouble t,GLdouble r);

static inline void MultiTexCoord3d(GLenum target,GLdouble s,GLdouble t,GLdouble r)
{
	static PFNMULTITEXCOORD3DPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3DPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3d",1,3));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3DVPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord3dv(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD3DVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3DVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3dv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3FPROC_HPP)(GLenum target,GLfloat s,GLfloat t,GLfloat r);

static inline void MultiTexCoord3f(GLenum target,GLfloat s,GLfloat t,GLfloat r)
{
	static PFNMULTITEXCOORD3FPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3FPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3f",1,3));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3FVPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord3fv(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD3FVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3FVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3fv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3IPROC_HPP)(GLenum target,GLint s,GLint t,GLint r);

static inline void MultiTexCoord3i(GLenum target,GLint s,GLint t,GLint r)
{
	static PFNMULTITEXCOORD3IPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3IPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3i",1,3));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3IVPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord3iv(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD3IVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3IVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3iv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3SPROC_HPP)(GLenum target,GLshort s,GLshort t,GLshort r);

static inline void MultiTexCoord3s(GLenum target,GLshort s,GLshort t,GLshort r)
{
	static PFNMULTITEXCOORD3SPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3SPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3s",1,3));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3SVPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord3sv(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD3SVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3SVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3sv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4DPROC_HPP)(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q);

static inline void MultiTexCoord4d(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q)
{
	static PFNMULTITEXCOORD4DPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4DPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4d",1,3));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4DVPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord4dv(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD4DVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4DVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4dv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4FPROC_HPP)(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q);

static inline void MultiTexCoord4f(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)
{
	static PFNMULTITEXCOORD4FPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4FPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4f",1,3));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4FVPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord4fv(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD4FVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4FVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4fv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4IPROC_HPP)(GLenum target,GLint s,GLint t,GLint r,GLint q);

static inline void MultiTexCoord4i(GLenum target,GLint s,GLint t,GLint r,GLint q)
{
	static PFNMULTITEXCOORD4IPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4IPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4i",1,3));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4IVPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord4iv(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD4IVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4IVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4iv",1,3));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4SPROC_HPP)(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q);

static inline void MultiTexCoord4s(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q)
{
	static PFNMULTITEXCOORD4SPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4SPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4s",1,3));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4SVPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord4sv(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD4SVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4SVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4sv",1,3));
	 fn(target,v);
}

typedef void (*PFNLOADTRANSPOSEMATRIXFPROC_HPP)(const GLfloat *m);

static inline void LoadTransposeMatrixf(const GLfloat *m)
{
	static PFNLOADTRANSPOSEMATRIXFPROC_HPP fn=reinterpret_cast<PFNLOADTRANSPOSEMATRIXFPROC_HPP>(_impl::_get_proc_address("glLoadTransposeMatrixf",1,3));
	 fn(m);
}

typedef void (*PFNLOADTRANSPOSEMATRIXDPROC_HPP)(const GLdouble *m);

static inline void LoadTransposeMatrixd(const GLdouble *m)
{
	static PFNLOADTRANSPOSEMATRIXDPROC_HPP fn=reinterpret_cast<PFNLOADTRANSPOSEMATRIXDPROC_HPP>(_impl::_get_proc_address("glLoadTransposeMatrixd",1,3));
	 fn(m);
}

typedef void (*PFNMULTTRANSPOSEMATRIXFPROC_HPP)(const GLfloat *m);

static inline void MultTransposeMatrixf(const GLfloat *m)
{
	static PFNMULTTRANSPOSEMATRIXFPROC_HPP fn=reinterpret_cast<PFNMULTTRANSPOSEMATRIXFPROC_HPP>(_impl::_get_proc_address("glMultTransposeMatrixf",1,3));
	 fn(m);
}

typedef void (*PFNMULTTRANSPOSEMATRIXDPROC_HPP)(const GLdouble *m);

static inline void MultTransposeMatrixd(const GLdouble *m)
{
	static PFNMULTTRANSPOSEMATRIXDPROC_HPP fn=reinterpret_cast<PFNMULTTRANSPOSEMATRIXDPROC_HPP>(_impl::_get_proc_address("glMultTransposeMatrixd",1,3));
	 fn(m);
}
#endif //(GLPROC_VERSION >= 13)
#if (GLPROC_VERSION >= 14)

#ifndef GL_VERSION_1_4

#define GL_VERSION_1_4
#ifndef GL_BLEND_DST_RGB
#define GL_BLEND_DST_RGB                                                0x80C8
#endif //GL_BLEND_DST_RGB
#ifndef GL_BLEND_SRC_RGB
#define GL_BLEND_SRC_RGB                                                0x80C9
#endif //GL_BLEND_SRC_RGB
#ifndef GL_BLEND_DST_ALPHA
#define GL_BLEND_DST_ALPHA                                              0x80CA
#endif //GL_BLEND_DST_ALPHA
#ifndef GL_BLEND_SRC_ALPHA
#define GL_BLEND_SRC_ALPHA                                              0x80CB
#endif //GL_BLEND_SRC_ALPHA
#ifndef GL_POINT_SIZE_MIN
#define GL_POINT_SIZE_MIN                                               0x8126
#endif //GL_POINT_SIZE_MIN
#ifndef GL_POINT_SIZE_MAX
#define GL_POINT_SIZE_MAX                                               0x8127
#endif //GL_POINT_SIZE_MAX
#ifndef GL_POINT_FADE_THRESHOLD_SIZE
#define GL_POINT_FADE_THRESHOLD_SIZE                                    0x8128
#endif //GL_POINT_FADE_THRESHOLD_SIZE
#ifndef GL_POINT_DISTANCE_ATTENUATION
#define GL_POINT_DISTANCE_ATTENUATION                                   0x8129
#endif //GL_POINT_DISTANCE_ATTENUATION
#ifndef GL_GENERATE_MIPMAP
#define GL_GENERATE_MIPMAP                                              0x8191
#endif //GL_GENERATE_MIPMAP
#ifndef GL_GENERATE_MIPMAP_HINT
#define GL_GENERATE_MIPMAP_HINT                                         0x8192
#endif //GL_GENERATE_MIPMAP_HINT
#ifndef GL_DEPTH_COMPONENT16
#define GL_DEPTH_COMPONENT16                                            0x81A5
#endif //GL_DEPTH_COMPONENT16
#ifndef GL_DEPTH_COMPONENT24
#define GL_DEPTH_COMPONENT24                                            0x81A6
#endif //GL_DEPTH_COMPONENT24
#ifndef GL_DEPTH_COMPONENT32
#define GL_DEPTH_COMPONENT32                                            0x81A7
#endif //GL_DEPTH_COMPONENT32
#ifndef GL_MIRRORED_REPEAT
#define GL_MIRRORED_REPEAT                                              0x8370
#endif //GL_MIRRORED_REPEAT
#ifndef GL_FOG_COORDINATE_SOURCE
#define GL_FOG_COORDINATE_SOURCE                                        0x8450
#endif //GL_FOG_COORDINATE_SOURCE
#ifndef GL_FOG_COORDINATE
#define GL_FOG_COORDINATE                                               0x8451
#endif //GL_FOG_COORDINATE
#ifndef GL_FRAGMENT_DEPTH
#define GL_FRAGMENT_DEPTH                                               0x8452
#endif //GL_FRAGMENT_DEPTH
#ifndef GL_CURRENT_FOG_COORDINATE
#define GL_CURRENT_FOG_COORDINATE                                       0x8453
#endif //GL_CURRENT_FOG_COORDINATE
#ifndef GL_FOG_COORDINATE_ARRAY_TYPE
#define GL_FOG_COORDINATE_ARRAY_TYPE                                    0x8454
#endif //GL_FOG_COORDINATE_ARRAY_TYPE
#ifndef GL_FOG_COORDINATE_ARRAY_STRIDE
#define GL_FOG_COORDINATE_ARRAY_STRIDE                                  0x8455
#endif //GL_FOG_COORDINATE_ARRAY_STRIDE
#ifndef GL_FOG_COORDINATE_ARRAY_POINTER
#define GL_FOG_COORDINATE_ARRAY_POINTER                                 0x8456
#endif //GL_FOG_COORDINATE_ARRAY_POINTER
#ifndef GL_FOG_COORDINATE_ARRAY
#define GL_FOG_COORDINATE_ARRAY                                         0x8457
#endif //GL_FOG_COORDINATE_ARRAY
#ifndef GL_COLOR_SUM
#define GL_COLOR_SUM                                                    0x8458
#endif //GL_COLOR_SUM
#ifndef GL_CURRENT_SECONDARY_COLOR
#define GL_CURRENT_SECONDARY_COLOR                                      0x8459
#endif //GL_CURRENT_SECONDARY_COLOR
#ifndef GL_SECONDARY_COLOR_ARRAY_SIZE
#define GL_SECONDARY_COLOR_ARRAY_SIZE                                   0x845A
#endif //GL_SECONDARY_COLOR_ARRAY_SIZE
#ifndef GL_SECONDARY_COLOR_ARRAY_TYPE
#define GL_SECONDARY_COLOR_ARRAY_TYPE                                   0x845B
#endif //GL_SECONDARY_COLOR_ARRAY_TYPE
#ifndef GL_SECONDARY_COLOR_ARRAY_STRIDE
#define GL_SECONDARY_COLOR_ARRAY_STRIDE                                 0x845C
#endif //GL_SECONDARY_COLOR_ARRAY_STRIDE
#ifndef GL_SECONDARY_COLOR_ARRAY_POINTER
#define GL_SECONDARY_COLOR_ARRAY_POINTER                                0x845D
#endif //GL_SECONDARY_COLOR_ARRAY_POINTER
#ifndef GL_SECONDARY_COLOR_ARRAY
#define GL_SECONDARY_COLOR_ARRAY                                        0x845E
#endif //GL_SECONDARY_COLOR_ARRAY
#ifndef GL_MAX_TEXTURE_LOD_BIAS
#define GL_MAX_TEXTURE_LOD_BIAS                                         0x84FD
#endif //GL_MAX_TEXTURE_LOD_BIAS
#ifndef GL_TEXTURE_FILTER_CONTROL
#define GL_TEXTURE_FILTER_CONTROL                                       0x8500
#endif //GL_TEXTURE_FILTER_CONTROL
#ifndef GL_TEXTURE_LOD_BIAS
#define GL_TEXTURE_LOD_BIAS                                             0x8501
#endif //GL_TEXTURE_LOD_BIAS
#ifndef GL_INCR_WRAP
#define GL_INCR_WRAP                                                    0x8507
#endif //GL_INCR_WRAP
#ifndef GL_DECR_WRAP
#define GL_DECR_WRAP                                                    0x8508
#endif //GL_DECR_WRAP
#ifndef GL_TEXTURE_DEPTH_SIZE
#define GL_TEXTURE_DEPTH_SIZE                                           0x884A
#endif //GL_TEXTURE_DEPTH_SIZE
#ifndef GL_DEPTH_TEXTURE_MODE
#define GL_DEPTH_TEXTURE_MODE                                           0x884B
#endif //GL_DEPTH_TEXTURE_MODE
#ifndef GL_TEXTURE_COMPARE_MODE
#define GL_TEXTURE_COMPARE_MODE                                         0x884C
#endif //GL_TEXTURE_COMPARE_MODE
#ifndef GL_TEXTURE_COMPARE_FUNC
#define GL_TEXTURE_COMPARE_FUNC                                         0x884D
#endif //GL_TEXTURE_COMPARE_FUNC
#ifndef GL_COMPARE_R_TO_TEXTURE
#define GL_COMPARE_R_TO_TEXTURE                                         0x884E
#endif //GL_COMPARE_R_TO_TEXTURE

#endif //GL_VERSION_1_4


typedef void (*PFNBLENDFUNCSEPARATEPROC_HPP)(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);

static inline void BlendFuncSeparate(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)
{
	static PFNBLENDFUNCSEPARATEPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparate",1,4));
	 fn(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha);
}

typedef void (*PFNMULTIDRAWARRAYSPROC_HPP)(GLenum mode,const GLint *first,const GLsizei *count,GLsizei drawcount);

static inline void MultiDrawArrays(GLenum mode,const GLint *first,const GLsizei *count,GLsizei drawcount)
{
	static PFNMULTIDRAWARRAYSPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWARRAYSPROC_HPP>(_impl::_get_proc_address("glMultiDrawArrays",1,4));
	 fn(mode,first,count,drawcount);
}

typedef void (*PFNMULTIDRAWELEMENTSPROC_HPP)(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei drawcount);

static inline void MultiDrawElements(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei drawcount)
{
	static PFNMULTIDRAWELEMENTSPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTSPROC_HPP>(_impl::_get_proc_address("glMultiDrawElements",1,4));
	 fn(mode,count,type,indices,drawcount);
}

typedef void (*PFNPOINTPARAMETERFPROC_HPP)(GLenum pname,GLfloat param);

static inline void PointParameterf(GLenum pname,GLfloat param)
{
	static PFNPOINTPARAMETERFPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFPROC_HPP>(_impl::_get_proc_address("glPointParameterf",1,4));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERFVPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void PointParameterfv(GLenum pname,const GLfloat *params)
{
	static PFNPOINTPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glPointParameterfv",1,4));
	 fn(pname,params);
}

typedef void (*PFNPOINTPARAMETERIPROC_HPP)(GLenum pname,GLint param);

static inline void PointParameteri(GLenum pname,GLint param)
{
	static PFNPOINTPARAMETERIPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERIPROC_HPP>(_impl::_get_proc_address("glPointParameteri",1,4));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERIVPROC_HPP)(GLenum pname,const GLint *params);

static inline void PointParameteriv(GLenum pname,const GLint *params)
{
	static PFNPOINTPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glPointParameteriv",1,4));
	 fn(pname,params);
}

typedef void (*PFNFOGCOORDFPROC_HPP)(GLfloat coord);

static inline void FogCoordf(GLfloat coord)
{
	static PFNFOGCOORDFPROC_HPP fn=reinterpret_cast<PFNFOGCOORDFPROC_HPP>(_impl::_get_proc_address("glFogCoordf",1,4));
	 fn(coord);
}

typedef void (*PFNFOGCOORDFVPROC_HPP)(const GLfloat *coord);

static inline void FogCoordfv(const GLfloat *coord)
{
	static PFNFOGCOORDFVPROC_HPP fn=reinterpret_cast<PFNFOGCOORDFVPROC_HPP>(_impl::_get_proc_address("glFogCoordfv",1,4));
	 fn(coord);
}

typedef void (*PFNFOGCOORDDPROC_HPP)(GLdouble coord);

static inline void FogCoordd(GLdouble coord)
{
	static PFNFOGCOORDDPROC_HPP fn=reinterpret_cast<PFNFOGCOORDDPROC_HPP>(_impl::_get_proc_address("glFogCoordd",1,4));
	 fn(coord);
}

typedef void (*PFNFOGCOORDDVPROC_HPP)(const GLdouble *coord);

static inline void FogCoorddv(const GLdouble *coord)
{
	static PFNFOGCOORDDVPROC_HPP fn=reinterpret_cast<PFNFOGCOORDDVPROC_HPP>(_impl::_get_proc_address("glFogCoorddv",1,4));
	 fn(coord);
}

typedef void (*PFNFOGCOORDPOINTERPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void FogCoordPointer(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNFOGCOORDPOINTERPROC_HPP fn=reinterpret_cast<PFNFOGCOORDPOINTERPROC_HPP>(_impl::_get_proc_address("glFogCoordPointer",1,4));
	 fn(type,stride,pointer);
}

typedef void (*PFNSECONDARYCOLOR3BPROC_HPP)(GLbyte red,GLbyte green,GLbyte blue);

static inline void SecondaryColor3b(GLbyte red,GLbyte green,GLbyte blue)
{
	static PFNSECONDARYCOLOR3BPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3BPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3b",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3BVPROC_HPP)(const GLbyte *v);

static inline void SecondaryColor3bv(const GLbyte *v)
{
	static PFNSECONDARYCOLOR3BVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3BVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3bv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3DPROC_HPP)(GLdouble red,GLdouble green,GLdouble blue);

static inline void SecondaryColor3d(GLdouble red,GLdouble green,GLdouble blue)
{
	static PFNSECONDARYCOLOR3DPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3DPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3d",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3DVPROC_HPP)(const GLdouble *v);

static inline void SecondaryColor3dv(const GLdouble *v)
{
	static PFNSECONDARYCOLOR3DVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3DVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3dv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3FPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue);

static inline void SecondaryColor3f(GLfloat red,GLfloat green,GLfloat blue)
{
	static PFNSECONDARYCOLOR3FPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3FPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3f",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3FVPROC_HPP)(const GLfloat *v);

static inline void SecondaryColor3fv(const GLfloat *v)
{
	static PFNSECONDARYCOLOR3FVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3FVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3fv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3IPROC_HPP)(GLint red,GLint green,GLint blue);

static inline void SecondaryColor3i(GLint red,GLint green,GLint blue)
{
	static PFNSECONDARYCOLOR3IPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3IPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3i",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3IVPROC_HPP)(const GLint *v);

static inline void SecondaryColor3iv(const GLint *v)
{
	static PFNSECONDARYCOLOR3IVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3IVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3iv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3SPROC_HPP)(GLshort red,GLshort green,GLshort blue);

static inline void SecondaryColor3s(GLshort red,GLshort green,GLshort blue)
{
	static PFNSECONDARYCOLOR3SPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3SPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3s",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3SVPROC_HPP)(const GLshort *v);

static inline void SecondaryColor3sv(const GLshort *v)
{
	static PFNSECONDARYCOLOR3SVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3SVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3sv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3UBPROC_HPP)(GLubyte red,GLubyte green,GLubyte blue);

static inline void SecondaryColor3ub(GLubyte red,GLubyte green,GLubyte blue)
{
	static PFNSECONDARYCOLOR3UBPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UBPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ub",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3UBVPROC_HPP)(const GLubyte *v);

static inline void SecondaryColor3ubv(const GLubyte *v)
{
	static PFNSECONDARYCOLOR3UBVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UBVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ubv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3UIPROC_HPP)(GLuint red,GLuint green,GLuint blue);

static inline void SecondaryColor3ui(GLuint red,GLuint green,GLuint blue)
{
	static PFNSECONDARYCOLOR3UIPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UIPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ui",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3UIVPROC_HPP)(const GLuint *v);

static inline void SecondaryColor3uiv(const GLuint *v)
{
	static PFNSECONDARYCOLOR3UIVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UIVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3uiv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3USPROC_HPP)(GLushort red,GLushort green,GLushort blue);

static inline void SecondaryColor3us(GLushort red,GLushort green,GLushort blue)
{
	static PFNSECONDARYCOLOR3USPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3USPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3us",1,4));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3USVPROC_HPP)(const GLushort *v);

static inline void SecondaryColor3usv(const GLushort *v)
{
	static PFNSECONDARYCOLOR3USVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3USVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3usv",1,4));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLORPOINTERPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void SecondaryColorPointer(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNSECONDARYCOLORPOINTERPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORPOINTERPROC_HPP>(_impl::_get_proc_address("glSecondaryColorPointer",1,4));
	 fn(size,type,stride,pointer);
}

typedef void (*PFNWINDOWPOS2DPROC_HPP)(GLdouble x,GLdouble y);

static inline void WindowPos2d(GLdouble x,GLdouble y)
{
	static PFNWINDOWPOS2DPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DPROC_HPP>(_impl::_get_proc_address("glWindowPos2d",1,4));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2DVPROC_HPP)(const GLdouble *v);

static inline void WindowPos2dv(const GLdouble *v)
{
	static PFNWINDOWPOS2DVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DVPROC_HPP>(_impl::_get_proc_address("glWindowPos2dv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2FPROC_HPP)(GLfloat x,GLfloat y);

static inline void WindowPos2f(GLfloat x,GLfloat y)
{
	static PFNWINDOWPOS2FPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FPROC_HPP>(_impl::_get_proc_address("glWindowPos2f",1,4));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2FVPROC_HPP)(const GLfloat *v);

static inline void WindowPos2fv(const GLfloat *v)
{
	static PFNWINDOWPOS2FVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FVPROC_HPP>(_impl::_get_proc_address("glWindowPos2fv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2IPROC_HPP)(GLint x,GLint y);

static inline void WindowPos2i(GLint x,GLint y)
{
	static PFNWINDOWPOS2IPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IPROC_HPP>(_impl::_get_proc_address("glWindowPos2i",1,4));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2IVPROC_HPP)(const GLint *v);

static inline void WindowPos2iv(const GLint *v)
{
	static PFNWINDOWPOS2IVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IVPROC_HPP>(_impl::_get_proc_address("glWindowPos2iv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2SPROC_HPP)(GLshort x,GLshort y);

static inline void WindowPos2s(GLshort x,GLshort y)
{
	static PFNWINDOWPOS2SPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SPROC_HPP>(_impl::_get_proc_address("glWindowPos2s",1,4));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2SVPROC_HPP)(const GLshort *v);

static inline void WindowPos2sv(const GLshort *v)
{
	static PFNWINDOWPOS2SVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SVPROC_HPP>(_impl::_get_proc_address("glWindowPos2sv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3DPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

static inline void WindowPos3d(GLdouble x,GLdouble y,GLdouble z)
{
	static PFNWINDOWPOS3DPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DPROC_HPP>(_impl::_get_proc_address("glWindowPos3d",1,4));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3DVPROC_HPP)(const GLdouble *v);

static inline void WindowPos3dv(const GLdouble *v)
{
	static PFNWINDOWPOS3DVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DVPROC_HPP>(_impl::_get_proc_address("glWindowPos3dv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3FPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

static inline void WindowPos3f(GLfloat x,GLfloat y,GLfloat z)
{
	static PFNWINDOWPOS3FPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FPROC_HPP>(_impl::_get_proc_address("glWindowPos3f",1,4));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3FVPROC_HPP)(const GLfloat *v);

static inline void WindowPos3fv(const GLfloat *v)
{
	static PFNWINDOWPOS3FVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FVPROC_HPP>(_impl::_get_proc_address("glWindowPos3fv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3IPROC_HPP)(GLint x,GLint y,GLint z);

static inline void WindowPos3i(GLint x,GLint y,GLint z)
{
	static PFNWINDOWPOS3IPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IPROC_HPP>(_impl::_get_proc_address("glWindowPos3i",1,4));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3IVPROC_HPP)(const GLint *v);

static inline void WindowPos3iv(const GLint *v)
{
	static PFNWINDOWPOS3IVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IVPROC_HPP>(_impl::_get_proc_address("glWindowPos3iv",1,4));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3SPROC_HPP)(GLshort x,GLshort y,GLshort z);

static inline void WindowPos3s(GLshort x,GLshort y,GLshort z)
{
	static PFNWINDOWPOS3SPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SPROC_HPP>(_impl::_get_proc_address("glWindowPos3s",1,4));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3SVPROC_HPP)(const GLshort *v);

static inline void WindowPos3sv(const GLshort *v)
{
	static PFNWINDOWPOS3SVPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SVPROC_HPP>(_impl::_get_proc_address("glWindowPos3sv",1,4));
	 fn(v);
}
#endif //(GLPROC_VERSION >= 14)
#if (GLPROC_VERSION >= 15)

#ifndef GL_VERSION_1_5

#define GL_VERSION_1_5
#ifndef GL_FOG_COORD_SRC
#define GL_FOG_COORD_SRC                                                0x8450
#endif //GL_FOG_COORD_SRC
#ifndef GL_FOG_COORD
#define GL_FOG_COORD                                                    0x8451
#endif //GL_FOG_COORD
#ifndef GL_CURRENT_FOG_COORD
#define GL_CURRENT_FOG_COORD                                            0x8453
#endif //GL_CURRENT_FOG_COORD
#ifndef GL_FOG_COORD_ARRAY_TYPE
#define GL_FOG_COORD_ARRAY_TYPE                                         0x8454
#endif //GL_FOG_COORD_ARRAY_TYPE
#ifndef GL_FOG_COORD_ARRAY_STRIDE
#define GL_FOG_COORD_ARRAY_STRIDE                                       0x8455
#endif //GL_FOG_COORD_ARRAY_STRIDE
#ifndef GL_FOG_COORD_ARRAY_POINTER
#define GL_FOG_COORD_ARRAY_POINTER                                      0x8456
#endif //GL_FOG_COORD_ARRAY_POINTER
#ifndef GL_FOG_COORD_ARRAY
#define GL_FOG_COORD_ARRAY                                              0x8457
#endif //GL_FOG_COORD_ARRAY
#ifndef GL_SRC0_RGB
#define GL_SRC0_RGB                                                     0x8580
#endif //GL_SRC0_RGB
#ifndef GL_SRC1_RGB
#define GL_SRC1_RGB                                                     0x8581
#endif //GL_SRC1_RGB
#ifndef GL_SRC2_RGB
#define GL_SRC2_RGB                                                     0x8582
#endif //GL_SRC2_RGB
#ifndef GL_SRC0_ALPHA
#define GL_SRC0_ALPHA                                                   0x8588
#endif //GL_SRC0_ALPHA
#ifndef GL_SRC1_ALPHA
#define GL_SRC1_ALPHA                                                   0x8589
#endif //GL_SRC1_ALPHA
#ifndef GL_SRC2_ALPHA
#define GL_SRC2_ALPHA                                                   0x858A
#endif //GL_SRC2_ALPHA
#ifndef GL_BUFFER_SIZE
#define GL_BUFFER_SIZE                                                  0x8764
#endif //GL_BUFFER_SIZE
#ifndef GL_BUFFER_USAGE
#define GL_BUFFER_USAGE                                                 0x8765
#endif //GL_BUFFER_USAGE
#ifndef GL_QUERY_COUNTER_BITS
#define GL_QUERY_COUNTER_BITS                                           0x8864
#endif //GL_QUERY_COUNTER_BITS
#ifndef GL_CURRENT_QUERY
#define GL_CURRENT_QUERY                                                0x8865
#endif //GL_CURRENT_QUERY
#ifndef GL_QUERY_RESULT
#define GL_QUERY_RESULT                                                 0x8866
#endif //GL_QUERY_RESULT
#ifndef GL_QUERY_RESULT_AVAILABLE
#define GL_QUERY_RESULT_AVAILABLE                                       0x8867
#endif //GL_QUERY_RESULT_AVAILABLE
#ifndef GL_ARRAY_BUFFER
#define GL_ARRAY_BUFFER                                                 0x8892
#endif //GL_ARRAY_BUFFER
#ifndef GL_ELEMENT_ARRAY_BUFFER
#define GL_ELEMENT_ARRAY_BUFFER                                         0x8893
#endif //GL_ELEMENT_ARRAY_BUFFER
#ifndef GL_ARRAY_BUFFER_BINDING
#define GL_ARRAY_BUFFER_BINDING                                         0x8894
#endif //GL_ARRAY_BUFFER_BINDING
#ifndef GL_ELEMENT_ARRAY_BUFFER_BINDING
#define GL_ELEMENT_ARRAY_BUFFER_BINDING                                 0x8895
#endif //GL_ELEMENT_ARRAY_BUFFER_BINDING
#ifndef GL_VERTEX_ARRAY_BUFFER_BINDING
#define GL_VERTEX_ARRAY_BUFFER_BINDING                                  0x8896
#endif //GL_VERTEX_ARRAY_BUFFER_BINDING
#ifndef GL_NORMAL_ARRAY_BUFFER_BINDING
#define GL_NORMAL_ARRAY_BUFFER_BINDING                                  0x8897
#endif //GL_NORMAL_ARRAY_BUFFER_BINDING
#ifndef GL_COLOR_ARRAY_BUFFER_BINDING
#define GL_COLOR_ARRAY_BUFFER_BINDING                                   0x8898
#endif //GL_COLOR_ARRAY_BUFFER_BINDING
#ifndef GL_INDEX_ARRAY_BUFFER_BINDING
#define GL_INDEX_ARRAY_BUFFER_BINDING                                   0x8899
#endif //GL_INDEX_ARRAY_BUFFER_BINDING
#ifndef GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING
#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING                           0x889A
#endif //GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING
#ifndef GL_EDGE_FLAG_ARRAY_BUFFER_BINDING
#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING                               0x889B
#endif //GL_EDGE_FLAG_ARRAY_BUFFER_BINDING
#ifndef GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING
#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING                         0x889C
#endif //GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING
#ifndef GL_FOG_COORD_ARRAY_BUFFER_BINDING
#define GL_FOG_COORD_ARRAY_BUFFER_BINDING                               0x889D
#endif //GL_FOG_COORD_ARRAY_BUFFER_BINDING
#ifndef GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING                          0x889D
#endif //GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
#ifndef GL_WEIGHT_ARRAY_BUFFER_BINDING
#define GL_WEIGHT_ARRAY_BUFFER_BINDING                                  0x889E
#endif //GL_WEIGHT_ARRAY_BUFFER_BINDING
#ifndef GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING                           0x889F
#endif //GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
#ifndef GL_READ_ONLY
#define GL_READ_ONLY                                                    0x88B8
#endif //GL_READ_ONLY
#ifndef GL_WRITE_ONLY
#define GL_WRITE_ONLY                                                   0x88B9
#endif //GL_WRITE_ONLY
#ifndef GL_READ_WRITE
#define GL_READ_WRITE                                                   0x88BA
#endif //GL_READ_WRITE
#ifndef GL_BUFFER_ACCESS
#define GL_BUFFER_ACCESS                                                0x88BB
#endif //GL_BUFFER_ACCESS
#ifndef GL_BUFFER_MAPPED
#define GL_BUFFER_MAPPED                                                0x88BC
#endif //GL_BUFFER_MAPPED
#ifndef GL_BUFFER_MAP_POINTER
#define GL_BUFFER_MAP_POINTER                                           0x88BD
#endif //GL_BUFFER_MAP_POINTER
#ifndef GL_STREAM_DRAW
#define GL_STREAM_DRAW                                                  0x88E0
#endif //GL_STREAM_DRAW
#ifndef GL_STREAM_READ
#define GL_STREAM_READ                                                  0x88E1
#endif //GL_STREAM_READ
#ifndef GL_STREAM_COPY
#define GL_STREAM_COPY                                                  0x88E2
#endif //GL_STREAM_COPY
#ifndef GL_STATIC_DRAW
#define GL_STATIC_DRAW                                                  0x88E4
#endif //GL_STATIC_DRAW
#ifndef GL_STATIC_READ
#define GL_STATIC_READ                                                  0x88E5
#endif //GL_STATIC_READ
#ifndef GL_STATIC_COPY
#define GL_STATIC_COPY                                                  0x88E6
#endif //GL_STATIC_COPY
#ifndef GL_DYNAMIC_DRAW
#define GL_DYNAMIC_DRAW                                                 0x88E8
#endif //GL_DYNAMIC_DRAW
#ifndef GL_DYNAMIC_READ
#define GL_DYNAMIC_READ                                                 0x88E9
#endif //GL_DYNAMIC_READ
#ifndef GL_DYNAMIC_COPY
#define GL_DYNAMIC_COPY                                                 0x88EA
#endif //GL_DYNAMIC_COPY
#ifndef GL_SAMPLES_PASSED
#define GL_SAMPLES_PASSED                                               0x8914
#endif //GL_SAMPLES_PASSED

#endif //GL_VERSION_1_5


typedef void (*PFNGENQUERIESPROC_HPP)(GLsizei n,GLuint *ids);

static inline void GenQueries(GLsizei n,GLuint *ids)
{
	static PFNGENQUERIESPROC_HPP fn=reinterpret_cast<PFNGENQUERIESPROC_HPP>(_impl::_get_proc_address("glGenQueries",1,5));
	 fn(n,ids);
}

typedef void (*PFNDELETEQUERIESPROC_HPP)(GLsizei n,const GLuint *ids);

static inline void DeleteQueries(GLsizei n,const GLuint *ids)
{
	static PFNDELETEQUERIESPROC_HPP fn=reinterpret_cast<PFNDELETEQUERIESPROC_HPP>(_impl::_get_proc_address("glDeleteQueries",1,5));
	 fn(n,ids);
}

typedef GLboolean (*PFNISQUERYPROC_HPP)(GLuint id);

static inline GLboolean IsQuery(GLuint id)
{
	static PFNISQUERYPROC_HPP fn=reinterpret_cast<PFNISQUERYPROC_HPP>(_impl::_get_proc_address("glIsQuery",1,5));
	return fn(id);
}

typedef void (*PFNBEGINQUERYPROC_HPP)(GLenum target,GLuint id);

static inline void BeginQuery(GLenum target,GLuint id)
{
	static PFNBEGINQUERYPROC_HPP fn=reinterpret_cast<PFNBEGINQUERYPROC_HPP>(_impl::_get_proc_address("glBeginQuery",1,5));
	 fn(target,id);
}

typedef void (*PFNENDQUERYPROC_HPP)(GLenum target);

static inline void EndQuery(GLenum target)
{
	static PFNENDQUERYPROC_HPP fn=reinterpret_cast<PFNENDQUERYPROC_HPP>(_impl::_get_proc_address("glEndQuery",1,5));
	 fn(target);
}

typedef void (*PFNGETQUERYIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetQueryiv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETQUERYIVPROC_HPP fn=reinterpret_cast<PFNGETQUERYIVPROC_HPP>(_impl::_get_proc_address("glGetQueryiv",1,5));
	 fn(target,pname,params);
}

typedef void (*PFNGETQUERYOBJECTIVPROC_HPP)(GLuint id,GLenum pname,GLint *params);

static inline void GetQueryObjectiv(GLuint id,GLenum pname,GLint *params)
{
	static PFNGETQUERYOBJECTIVPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTIVPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectiv",1,5));
	 fn(id,pname,params);
}

typedef void (*PFNGETQUERYOBJECTUIVPROC_HPP)(GLuint id,GLenum pname,GLuint *params);

static inline void GetQueryObjectuiv(GLuint id,GLenum pname,GLuint *params)
{
	static PFNGETQUERYOBJECTUIVPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTUIVPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectuiv",1,5));
	 fn(id,pname,params);
}

typedef void (*PFNBINDBUFFERPROC_HPP)(GLenum target,GLuint buffer);

static inline void BindBuffer(GLenum target,GLuint buffer)
{
	static PFNBINDBUFFERPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERPROC_HPP>(_impl::_get_proc_address("glBindBuffer",1,5));
	 fn(target,buffer);
}

typedef void (*PFNDELETEBUFFERSPROC_HPP)(GLsizei n,const GLuint *buffers);

static inline void DeleteBuffers(GLsizei n,const GLuint *buffers)
{
	static PFNDELETEBUFFERSPROC_HPP fn=reinterpret_cast<PFNDELETEBUFFERSPROC_HPP>(_impl::_get_proc_address("glDeleteBuffers",1,5));
	 fn(n,buffers);
}

typedef void (*PFNGENBUFFERSPROC_HPP)(GLsizei n,GLuint *buffers);

static inline void GenBuffers(GLsizei n,GLuint *buffers)
{
	static PFNGENBUFFERSPROC_HPP fn=reinterpret_cast<PFNGENBUFFERSPROC_HPP>(_impl::_get_proc_address("glGenBuffers",1,5));
	 fn(n,buffers);
}

typedef GLboolean (*PFNISBUFFERPROC_HPP)(GLuint buffer);

static inline GLboolean IsBuffer(GLuint buffer)
{
	static PFNISBUFFERPROC_HPP fn=reinterpret_cast<PFNISBUFFERPROC_HPP>(_impl::_get_proc_address("glIsBuffer",1,5));
	return fn(buffer);
}

typedef void (*PFNBUFFERDATAPROC_HPP)(GLenum target,GLsizeiptr size,const GLvoid *data,GLenum usage);

static inline void BufferData(GLenum target,GLsizeiptr size,const GLvoid *data,GLenum usage)
{
	static PFNBUFFERDATAPROC_HPP fn=reinterpret_cast<PFNBUFFERDATAPROC_HPP>(_impl::_get_proc_address("glBufferData",1,5));
	 fn(target,size,data,usage);
}

typedef void (*PFNBUFFERSUBDATAPROC_HPP)(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid *data);

static inline void BufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid *data)
{
	static PFNBUFFERSUBDATAPROC_HPP fn=reinterpret_cast<PFNBUFFERSUBDATAPROC_HPP>(_impl::_get_proc_address("glBufferSubData",1,5));
	 fn(target,offset,size,data);
}

typedef void (*PFNGETBUFFERSUBDATAPROC_HPP)(GLenum target,GLintptr offset,GLsizeiptr size,GLvoid *data);

static inline void GetBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,GLvoid *data)
{
	static PFNGETBUFFERSUBDATAPROC_HPP fn=reinterpret_cast<PFNGETBUFFERSUBDATAPROC_HPP>(_impl::_get_proc_address("glGetBufferSubData",1,5));
	 fn(target,offset,size,data);
}

typedef GLvoid* (*PFNMAPBUFFERPROC_HPP)(GLenum target,GLenum access);

static inline GLvoid* MapBuffer(GLenum target,GLenum access)
{
	static PFNMAPBUFFERPROC_HPP fn=reinterpret_cast<PFNMAPBUFFERPROC_HPP>(_impl::_get_proc_address("glMapBuffer",1,5));
	return fn(target,access);
}

typedef GLboolean (*PFNUNMAPBUFFERPROC_HPP)(GLenum target);

static inline GLboolean UnmapBuffer(GLenum target)
{
	static PFNUNMAPBUFFERPROC_HPP fn=reinterpret_cast<PFNUNMAPBUFFERPROC_HPP>(_impl::_get_proc_address("glUnmapBuffer",1,5));
	return fn(target);
}

typedef void (*PFNGETBUFFERPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetBufferParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETBUFFERPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetBufferParameteriv",1,5));
	 fn(target,pname,params);
}

typedef void (*PFNGETBUFFERPOINTERVPROC_HPP)(GLenum target,GLenum pname,GLvoid* *params);

static inline void GetBufferPointerv(GLenum target,GLenum pname,GLvoid* *params)
{
	static PFNGETBUFFERPOINTERVPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPOINTERVPROC_HPP>(_impl::_get_proc_address("glGetBufferPointerv",1,5));
	 fn(target,pname,params);
}
#endif //(GLPROC_VERSION >= 15)
#if (GLPROC_VERSION >= 20)

#ifndef GL_VERSION_2_0

#define GL_VERSION_2_0
#ifndef GL_BLEND_EQUATION_RGB
#define GL_BLEND_EQUATION_RGB                                           0x8009
#endif //GL_BLEND_EQUATION_RGB
#ifndef GL_BLEND_EQUATION
#define GL_BLEND_EQUATION                                               0x8009
#endif //GL_BLEND_EQUATION
#ifndef GL_VERTEX_ATTRIB_ARRAY_ENABLED
#define GL_VERTEX_ATTRIB_ARRAY_ENABLED                                  0x8622
#endif //GL_VERTEX_ATTRIB_ARRAY_ENABLED
#ifndef GL_VERTEX_ATTRIB_ARRAY_SIZE
#define GL_VERTEX_ATTRIB_ARRAY_SIZE                                     0x8623
#endif //GL_VERTEX_ATTRIB_ARRAY_SIZE
#ifndef GL_VERTEX_ATTRIB_ARRAY_STRIDE
#define GL_VERTEX_ATTRIB_ARRAY_STRIDE                                   0x8624
#endif //GL_VERTEX_ATTRIB_ARRAY_STRIDE
#ifndef GL_VERTEX_ATTRIB_ARRAY_TYPE
#define GL_VERTEX_ATTRIB_ARRAY_TYPE                                     0x8625
#endif //GL_VERTEX_ATTRIB_ARRAY_TYPE
#ifndef GL_CURRENT_VERTEX_ATTRIB
#define GL_CURRENT_VERTEX_ATTRIB                                        0x8626
#endif //GL_CURRENT_VERTEX_ATTRIB
#ifndef GL_VERTEX_PROGRAM_POINT_SIZE
#define GL_VERTEX_PROGRAM_POINT_SIZE                                    0x8642
#endif //GL_VERTEX_PROGRAM_POINT_SIZE
#ifndef GL_VERTEX_PROGRAM_TWO_SIDE
#define GL_VERTEX_PROGRAM_TWO_SIDE                                      0x8643
#endif //GL_VERTEX_PROGRAM_TWO_SIDE
#ifndef GL_VERTEX_ATTRIB_ARRAY_POINTER
#define GL_VERTEX_ATTRIB_ARRAY_POINTER                                  0x8645
#endif //GL_VERTEX_ATTRIB_ARRAY_POINTER
#ifndef GL_STENCIL_BACK_FUNC
#define GL_STENCIL_BACK_FUNC                                            0x8800
#endif //GL_STENCIL_BACK_FUNC
#ifndef GL_STENCIL_BACK_FAIL_ATI
#define GL_STENCIL_BACK_FAIL_ATI                                        0x8801
#endif //GL_STENCIL_BACK_FAIL_ATI
#ifndef GL_STENCIL_BACK_FAIL
#define GL_STENCIL_BACK_FAIL                                            0x8801
#endif //GL_STENCIL_BACK_FAIL
#ifndef GL_STENCIL_BACK_PASS_DEPTH_FAIL
#define GL_STENCIL_BACK_PASS_DEPTH_FAIL                                 0x8802
#endif //GL_STENCIL_BACK_PASS_DEPTH_FAIL
#ifndef GL_STENCIL_BACK_PASS_DEPTH_PASS
#define GL_STENCIL_BACK_PASS_DEPTH_PASS                                 0x8803
#endif //GL_STENCIL_BACK_PASS_DEPTH_PASS
#ifndef GL_MAX_DRAW_BUFFERS
#define GL_MAX_DRAW_BUFFERS                                             0x8824
#endif //GL_MAX_DRAW_BUFFERS
#ifndef GL_DRAW_BUFFER0
#define GL_DRAW_BUFFER0                                                 0x8825
#endif //GL_DRAW_BUFFER0
#ifndef GL_DRAW_BUFFER1
#define GL_DRAW_BUFFER1                                                 0x8826
#endif //GL_DRAW_BUFFER1
#ifndef GL_DRAW_BUFFER2
#define GL_DRAW_BUFFER2                                                 0x8827
#endif //GL_DRAW_BUFFER2
#ifndef GL_DRAW_BUFFER3
#define GL_DRAW_BUFFER3                                                 0x8828
#endif //GL_DRAW_BUFFER3
#ifndef GL_DRAW_BUFFER4
#define GL_DRAW_BUFFER4                                                 0x8829
#endif //GL_DRAW_BUFFER4
#ifndef GL_DRAW_BUFFER5
#define GL_DRAW_BUFFER5                                                 0x882A
#endif //GL_DRAW_BUFFER5
#ifndef GL_DRAW_BUFFER6
#define GL_DRAW_BUFFER6                                                 0x882B
#endif //GL_DRAW_BUFFER6
#ifndef GL_DRAW_BUFFER7
#define GL_DRAW_BUFFER7                                                 0x882C
#endif //GL_DRAW_BUFFER7
#ifndef GL_DRAW_BUFFER8
#define GL_DRAW_BUFFER8                                                 0x882D
#endif //GL_DRAW_BUFFER8
#ifndef GL_DRAW_BUFFER9
#define GL_DRAW_BUFFER9                                                 0x882E
#endif //GL_DRAW_BUFFER9
#ifndef GL_DRAW_BUFFER10
#define GL_DRAW_BUFFER10                                                0x882F
#endif //GL_DRAW_BUFFER10
#ifndef GL_DRAW_BUFFER11
#define GL_DRAW_BUFFER11                                                0x8830
#endif //GL_DRAW_BUFFER11
#ifndef GL_DRAW_BUFFER12
#define GL_DRAW_BUFFER12                                                0x8831
#endif //GL_DRAW_BUFFER12
#ifndef GL_DRAW_BUFFER13
#define GL_DRAW_BUFFER13                                                0x8832
#endif //GL_DRAW_BUFFER13
#ifndef GL_DRAW_BUFFER14
#define GL_DRAW_BUFFER14                                                0x8833
#endif //GL_DRAW_BUFFER14
#ifndef GL_DRAW_BUFFER15
#define GL_DRAW_BUFFER15                                                0x8834
#endif //GL_DRAW_BUFFER15
#ifndef GL_BLEND_EQUATION_ALPHA
#define GL_BLEND_EQUATION_ALPHA                                         0x883D
#endif //GL_BLEND_EQUATION_ALPHA
#ifndef GL_POINT_SPRITE
#define GL_POINT_SPRITE                                                 0x8861
#endif //GL_POINT_SPRITE
#ifndef GL_COORD_REPLACE
#define GL_COORD_REPLACE                                                0x8862
#endif //GL_COORD_REPLACE
#ifndef GL_MAX_VERTEX_ATTRIBS
#define GL_MAX_VERTEX_ATTRIBS                                           0x8869
#endif //GL_MAX_VERTEX_ATTRIBS
#ifndef GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED                               0x886A
#endif //GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
#ifndef GL_MAX_TEXTURE_COORDS
#define GL_MAX_TEXTURE_COORDS                                           0x8871
#endif //GL_MAX_TEXTURE_COORDS
#ifndef GL_MAX_TEXTURE_IMAGE_UNITS
#define GL_MAX_TEXTURE_IMAGE_UNITS                                      0x8872
#endif //GL_MAX_TEXTURE_IMAGE_UNITS
#ifndef GL_CURRENT_PROGRAM
#define GL_CURRENT_PROGRAM                                              0x8B8D
#endif //GL_CURRENT_PROGRAM
#ifndef GL_POINT_SPRITE_COORD_ORIGIN
#define GL_POINT_SPRITE_COORD_ORIGIN                                    0x8CA0
#endif //GL_POINT_SPRITE_COORD_ORIGIN
#ifndef GL_LOWER_LEFT
#define GL_LOWER_LEFT                                                   0x8CA1
#endif //GL_LOWER_LEFT
#ifndef GL_UPPER_LEFT
#define GL_UPPER_LEFT                                                   0x8CA2
#endif //GL_UPPER_LEFT
#ifndef GL_STENCIL_BACK_REF
#define GL_STENCIL_BACK_REF                                             0x8CA3
#endif //GL_STENCIL_BACK_REF
#ifndef GL_STENCIL_BACK_VALUE_MASK
#define GL_STENCIL_BACK_VALUE_MASK                                      0x8CA4
#endif //GL_STENCIL_BACK_VALUE_MASK
#ifndef GL_STENCIL_BACK_WRITEMASK
#define GL_STENCIL_BACK_WRITEMASK                                       0x8CA5
#endif //GL_STENCIL_BACK_WRITEMASK

#endif //GL_VERSION_2_0


typedef void (*PFNBLENDEQUATIONSEPARATEPROC_HPP)(GLenum modeRGB,GLenum modeAlpha);

static inline void BlendEquationSeparate(GLenum modeRGB,GLenum modeAlpha)
{
	static PFNBLENDEQUATIONSEPARATEPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONSEPARATEPROC_HPP>(_impl::_get_proc_address("glBlendEquationSeparate",2,0));
	 fn(modeRGB,modeAlpha);
}

typedef void (*PFNDRAWBUFFERSPROC_HPP)(GLsizei n,const GLenum *bufs);

static inline void DrawBuffers(GLsizei n,const GLenum *bufs)
{
	static PFNDRAWBUFFERSPROC_HPP fn=reinterpret_cast<PFNDRAWBUFFERSPROC_HPP>(_impl::_get_proc_address("glDrawBuffers",2,0));
	 fn(n,bufs);
}

typedef void (*PFNSTENCILOPSEPARATEPROC_HPP)(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass);

static inline void StencilOpSeparate(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)
{
	static PFNSTENCILOPSEPARATEPROC_HPP fn=reinterpret_cast<PFNSTENCILOPSEPARATEPROC_HPP>(_impl::_get_proc_address("glStencilOpSeparate",2,0));
	 fn(face,sfail,dpfail,dppass);
}

typedef void (*PFNSTENCILFUNCSEPARATEPROC_HPP)(GLenum face,GLenum func,GLint ref,GLuint mask);

static inline void StencilFuncSeparate(GLenum face,GLenum func,GLint ref,GLuint mask)
{
	static PFNSTENCILFUNCSEPARATEPROC_HPP fn=reinterpret_cast<PFNSTENCILFUNCSEPARATEPROC_HPP>(_impl::_get_proc_address("glStencilFuncSeparate",2,0));
	 fn(face,func,ref,mask);
}

typedef void (*PFNSTENCILMASKSEPARATEPROC_HPP)(GLenum face,GLuint mask);

static inline void StencilMaskSeparate(GLenum face,GLuint mask)
{
	static PFNSTENCILMASKSEPARATEPROC_HPP fn=reinterpret_cast<PFNSTENCILMASKSEPARATEPROC_HPP>(_impl::_get_proc_address("glStencilMaskSeparate",2,0));
	 fn(face,mask);
}

typedef void (*PFNATTACHSHADERPROC_HPP)(GLuint program,GLuint shader);

static inline void AttachShader(GLuint program,GLuint shader)
{
	static PFNATTACHSHADERPROC_HPP fn=reinterpret_cast<PFNATTACHSHADERPROC_HPP>(_impl::_get_proc_address("glAttachShader",2,0));
	 fn(program,shader);
}

typedef void (*PFNBINDATTRIBLOCATIONPROC_HPP)(GLuint program,GLuint index,const GLchar *name);

static inline void BindAttribLocation(GLuint program,GLuint index,const GLchar *name)
{
	static PFNBINDATTRIBLOCATIONPROC_HPP fn=reinterpret_cast<PFNBINDATTRIBLOCATIONPROC_HPP>(_impl::_get_proc_address("glBindAttribLocation",2,0));
	 fn(program,index,name);
}

typedef void (*PFNCOMPILESHADERPROC_HPP)(GLuint shader);

static inline void CompileShader(GLuint shader)
{
	static PFNCOMPILESHADERPROC_HPP fn=reinterpret_cast<PFNCOMPILESHADERPROC_HPP>(_impl::_get_proc_address("glCompileShader",2,0));
	 fn(shader);
}

typedef GLuint (*PFNCREATEPROGRAMPROC_HPP)();

static inline GLuint CreateProgram()
{
	static PFNCREATEPROGRAMPROC_HPP fn=reinterpret_cast<PFNCREATEPROGRAMPROC_HPP>(_impl::_get_proc_address("glCreateProgram",2,0));
	return fn();
}

typedef GLuint (*PFNCREATESHADERPROC_HPP)(GLenum type);

static inline GLuint CreateShader(GLenum type)
{
	static PFNCREATESHADERPROC_HPP fn=reinterpret_cast<PFNCREATESHADERPROC_HPP>(_impl::_get_proc_address("glCreateShader",2,0));
	return fn(type);
}

typedef void (*PFNDELETEPROGRAMPROC_HPP)(GLuint program);

static inline void DeleteProgram(GLuint program)
{
	static PFNDELETEPROGRAMPROC_HPP fn=reinterpret_cast<PFNDELETEPROGRAMPROC_HPP>(_impl::_get_proc_address("glDeleteProgram",2,0));
	 fn(program);
}

typedef void (*PFNDELETESHADERPROC_HPP)(GLuint shader);

static inline void DeleteShader(GLuint shader)
{
	static PFNDELETESHADERPROC_HPP fn=reinterpret_cast<PFNDELETESHADERPROC_HPP>(_impl::_get_proc_address("glDeleteShader",2,0));
	 fn(shader);
}

typedef void (*PFNDETACHSHADERPROC_HPP)(GLuint program,GLuint shader);

static inline void DetachShader(GLuint program,GLuint shader)
{
	static PFNDETACHSHADERPROC_HPP fn=reinterpret_cast<PFNDETACHSHADERPROC_HPP>(_impl::_get_proc_address("glDetachShader",2,0));
	 fn(program,shader);
}

typedef void (*PFNDISABLEVERTEXATTRIBARRAYPROC_HPP)(GLuint index);

static inline void DisableVertexAttribArray(GLuint index)
{
	static PFNDISABLEVERTEXATTRIBARRAYPROC_HPP fn=reinterpret_cast<PFNDISABLEVERTEXATTRIBARRAYPROC_HPP>(_impl::_get_proc_address("glDisableVertexAttribArray",2,0));
	 fn(index);
}

typedef void (*PFNENABLEVERTEXATTRIBARRAYPROC_HPP)(GLuint index);

static inline void EnableVertexAttribArray(GLuint index)
{
	static PFNENABLEVERTEXATTRIBARRAYPROC_HPP fn=reinterpret_cast<PFNENABLEVERTEXATTRIBARRAYPROC_HPP>(_impl::_get_proc_address("glEnableVertexAttribArray",2,0));
	 fn(index);
}

typedef void (*PFNGETACTIVEATTRIBPROC_HPP)(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLint *size,GLenum *type,GLchar *name);

static inline void GetActiveAttrib(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLint *size,GLenum *type,GLchar *name)
{
	static PFNGETACTIVEATTRIBPROC_HPP fn=reinterpret_cast<PFNGETACTIVEATTRIBPROC_HPP>(_impl::_get_proc_address("glGetActiveAttrib",2,0));
	 fn(program,index,bufSize,length,size,type,name);
}

typedef void (*PFNGETACTIVEUNIFORMPROC_HPP)(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLint *size,GLenum *type,GLchar *name);

static inline void GetActiveUniform(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLint *size,GLenum *type,GLchar *name)
{
	static PFNGETACTIVEUNIFORMPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMPROC_HPP>(_impl::_get_proc_address("glGetActiveUniform",2,0));
	 fn(program,index,bufSize,length,size,type,name);
}

typedef void (*PFNGETATTACHEDSHADERSPROC_HPP)(GLuint program,GLsizei maxCount,GLsizei *count,GLuint *obj);

static inline void GetAttachedShaders(GLuint program,GLsizei maxCount,GLsizei *count,GLuint *obj)
{
	static PFNGETATTACHEDSHADERSPROC_HPP fn=reinterpret_cast<PFNGETATTACHEDSHADERSPROC_HPP>(_impl::_get_proc_address("glGetAttachedShaders",2,0));
	 fn(program,maxCount,count,obj);
}

typedef GLint (*PFNGETATTRIBLOCATIONPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetAttribLocation(GLuint program,const GLchar *name)
{
	static PFNGETATTRIBLOCATIONPROC_HPP fn=reinterpret_cast<PFNGETATTRIBLOCATIONPROC_HPP>(_impl::_get_proc_address("glGetAttribLocation",2,0));
	return fn(program,name);
}

typedef void (*PFNGETPROGRAMIVPROC_HPP)(GLuint program,GLenum pname,GLint *params);

static inline void GetProgramiv(GLuint program,GLenum pname,GLint *params)
{
	static PFNGETPROGRAMIVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMIVPROC_HPP>(_impl::_get_proc_address("glGetProgramiv",2,0));
	 fn(program,pname,params);
}

typedef void (*PFNGETPROGRAMINFOLOGPROC_HPP)(GLuint program,GLsizei bufSize,GLsizei *length,GLchar *infoLog);

static inline void GetProgramInfoLog(GLuint program,GLsizei bufSize,GLsizei *length,GLchar *infoLog)
{
	static PFNGETPROGRAMINFOLOGPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMINFOLOGPROC_HPP>(_impl::_get_proc_address("glGetProgramInfoLog",2,0));
	 fn(program,bufSize,length,infoLog);
}

typedef void (*PFNGETSHADERIVPROC_HPP)(GLuint shader,GLenum pname,GLint *params);

static inline void GetShaderiv(GLuint shader,GLenum pname,GLint *params)
{
	static PFNGETSHADERIVPROC_HPP fn=reinterpret_cast<PFNGETSHADERIVPROC_HPP>(_impl::_get_proc_address("glGetShaderiv",2,0));
	 fn(shader,pname,params);
}

typedef void (*PFNGETSHADERINFOLOGPROC_HPP)(GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *infoLog);

static inline void GetShaderInfoLog(GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *infoLog)
{
	static PFNGETSHADERINFOLOGPROC_HPP fn=reinterpret_cast<PFNGETSHADERINFOLOGPROC_HPP>(_impl::_get_proc_address("glGetShaderInfoLog",2,0));
	 fn(shader,bufSize,length,infoLog);
}

typedef void (*PFNGETSHADERSOURCEPROC_HPP)(GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *source);

static inline void GetShaderSource(GLuint shader,GLsizei bufSize,GLsizei *length,GLchar *source)
{
	static PFNGETSHADERSOURCEPROC_HPP fn=reinterpret_cast<PFNGETSHADERSOURCEPROC_HPP>(_impl::_get_proc_address("glGetShaderSource",2,0));
	 fn(shader,bufSize,length,source);
}

typedef GLint (*PFNGETUNIFORMLOCATIONPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetUniformLocation(GLuint program,const GLchar *name)
{
	static PFNGETUNIFORMLOCATIONPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMLOCATIONPROC_HPP>(_impl::_get_proc_address("glGetUniformLocation",2,0));
	return fn(program,name);
}

typedef void (*PFNGETUNIFORMFVPROC_HPP)(GLuint program,GLint location,GLfloat *params);

static inline void GetUniformfv(GLuint program,GLint location,GLfloat *params)
{
	static PFNGETUNIFORMFVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMFVPROC_HPP>(_impl::_get_proc_address("glGetUniformfv",2,0));
	 fn(program,location,params);
}

typedef void (*PFNGETUNIFORMIVPROC_HPP)(GLuint program,GLint location,GLint *params);

static inline void GetUniformiv(GLuint program,GLint location,GLint *params)
{
	static PFNGETUNIFORMIVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMIVPROC_HPP>(_impl::_get_proc_address("glGetUniformiv",2,0));
	 fn(program,location,params);
}

typedef void (*PFNGETVERTEXATTRIBDVPROC_HPP)(GLuint index,GLenum pname,GLdouble *params);

static inline void GetVertexAttribdv(GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETVERTEXATTRIBDVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBDVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribdv",2,0));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBFVPROC_HPP)(GLuint index,GLenum pname,GLfloat *params);

static inline void GetVertexAttribfv(GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETVERTEXATTRIBFVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBFVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribfv",2,0));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBIVPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribiv(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBIVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribiv",2,0));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBPOINTERVPROC_HPP)(GLuint index,GLenum pname,GLvoid* *pointer);

static inline void GetVertexAttribPointerv(GLuint index,GLenum pname,GLvoid* *pointer)
{
	static PFNGETVERTEXATTRIBPOINTERVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBPOINTERVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribPointerv",2,0));
	 fn(index,pname,pointer);
}

typedef GLboolean (*PFNISPROGRAMPROC_HPP)(GLuint program);

static inline GLboolean IsProgram(GLuint program)
{
	static PFNISPROGRAMPROC_HPP fn=reinterpret_cast<PFNISPROGRAMPROC_HPP>(_impl::_get_proc_address("glIsProgram",2,0));
	return fn(program);
}

typedef GLboolean (*PFNISSHADERPROC_HPP)(GLuint shader);

static inline GLboolean IsShader(GLuint shader)
{
	static PFNISSHADERPROC_HPP fn=reinterpret_cast<PFNISSHADERPROC_HPP>(_impl::_get_proc_address("glIsShader",2,0));
	return fn(shader);
}

typedef void (*PFNLINKPROGRAMPROC_HPP)(GLuint program);

static inline void LinkProgram(GLuint program)
{
	static PFNLINKPROGRAMPROC_HPP fn=reinterpret_cast<PFNLINKPROGRAMPROC_HPP>(_impl::_get_proc_address("glLinkProgram",2,0));
	 fn(program);
}

typedef void (*PFNSHADERSOURCEPROC_HPP)(GLuint shader,GLsizei count,const GLchar* const *string,const GLint *length);

static inline void ShaderSource(GLuint shader,GLsizei count,const GLchar* const *string,const GLint *length)
{
	static PFNSHADERSOURCEPROC_HPP fn=reinterpret_cast<PFNSHADERSOURCEPROC_HPP>(_impl::_get_proc_address("glShaderSource",2,0));
	 fn(shader,count,string,length);
}

typedef void (*PFNUSEPROGRAMPROC_HPP)(GLuint program);

static inline void UseProgram(GLuint program)
{
	static PFNUSEPROGRAMPROC_HPP fn=reinterpret_cast<PFNUSEPROGRAMPROC_HPP>(_impl::_get_proc_address("glUseProgram",2,0));
	 fn(program);
}

typedef void (*PFNUNIFORM1FPROC_HPP)(GLint location,GLfloat v0);

static inline void Uniform1f(GLint location,GLfloat v0)
{
	static PFNUNIFORM1FPROC_HPP fn=reinterpret_cast<PFNUNIFORM1FPROC_HPP>(_impl::_get_proc_address("glUniform1f",2,0));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2FPROC_HPP)(GLint location,GLfloat v0,GLfloat v1);

static inline void Uniform2f(GLint location,GLfloat v0,GLfloat v1)
{
	static PFNUNIFORM2FPROC_HPP fn=reinterpret_cast<PFNUNIFORM2FPROC_HPP>(_impl::_get_proc_address("glUniform2f",2,0));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3FPROC_HPP)(GLint location,GLfloat v0,GLfloat v1,GLfloat v2);

static inline void Uniform3f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2)
{
	static PFNUNIFORM3FPROC_HPP fn=reinterpret_cast<PFNUNIFORM3FPROC_HPP>(_impl::_get_proc_address("glUniform3f",2,0));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4FPROC_HPP)(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);

static inline void Uniform4f(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)
{
	static PFNUNIFORM4FPROC_HPP fn=reinterpret_cast<PFNUNIFORM4FPROC_HPP>(_impl::_get_proc_address("glUniform4f",2,0));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1IPROC_HPP)(GLint location,GLint v0);

static inline void Uniform1i(GLint location,GLint v0)
{
	static PFNUNIFORM1IPROC_HPP fn=reinterpret_cast<PFNUNIFORM1IPROC_HPP>(_impl::_get_proc_address("glUniform1i",2,0));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2IPROC_HPP)(GLint location,GLint v0,GLint v1);

static inline void Uniform2i(GLint location,GLint v0,GLint v1)
{
	static PFNUNIFORM2IPROC_HPP fn=reinterpret_cast<PFNUNIFORM2IPROC_HPP>(_impl::_get_proc_address("glUniform2i",2,0));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3IPROC_HPP)(GLint location,GLint v0,GLint v1,GLint v2);

static inline void Uniform3i(GLint location,GLint v0,GLint v1,GLint v2)
{
	static PFNUNIFORM3IPROC_HPP fn=reinterpret_cast<PFNUNIFORM3IPROC_HPP>(_impl::_get_proc_address("glUniform3i",2,0));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4IPROC_HPP)(GLint location,GLint v0,GLint v1,GLint v2,GLint v3);

static inline void Uniform4i(GLint location,GLint v0,GLint v1,GLint v2,GLint v3)
{
	static PFNUNIFORM4IPROC_HPP fn=reinterpret_cast<PFNUNIFORM4IPROC_HPP>(_impl::_get_proc_address("glUniform4i",2,0));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1FVPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform1fv(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM1FVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1FVPROC_HPP>(_impl::_get_proc_address("glUniform1fv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2FVPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform2fv(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM2FVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2FVPROC_HPP>(_impl::_get_proc_address("glUniform2fv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3FVPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform3fv(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM3FVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3FVPROC_HPP>(_impl::_get_proc_address("glUniform3fv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4FVPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform4fv(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM4FVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4FVPROC_HPP>(_impl::_get_proc_address("glUniform4fv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM1IVPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform1iv(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM1IVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1IVPROC_HPP>(_impl::_get_proc_address("glUniform1iv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2IVPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform2iv(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM2IVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2IVPROC_HPP>(_impl::_get_proc_address("glUniform2iv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3IVPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform3iv(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM3IVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3IVPROC_HPP>(_impl::_get_proc_address("glUniform3iv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4IVPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform4iv(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM4IVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4IVPROC_HPP>(_impl::_get_proc_address("glUniform4iv",2,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORMMATRIX2FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX2FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2fv",2,0));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX3FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3fv",2,0));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX4FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4fv",2,0));
	 fn(location,count,transpose,value);
}

typedef void (*PFNVALIDATEPROGRAMPROC_HPP)(GLuint program);

static inline void ValidateProgram(GLuint program)
{
	static PFNVALIDATEPROGRAMPROC_HPP fn=reinterpret_cast<PFNVALIDATEPROGRAMPROC_HPP>(_impl::_get_proc_address("glValidateProgram",2,0));
	 fn(program);
}

typedef void (*PFNVERTEXATTRIB1DPROC_HPP)(GLuint index,GLdouble x);

static inline void VertexAttrib1d(GLuint index,GLdouble x)
{
	static PFNVERTEXATTRIB1DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1d",2,0));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib1dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB1DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1dv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1FPROC_HPP)(GLuint index,GLfloat x);

static inline void VertexAttrib1f(GLuint index,GLfloat x)
{
	static PFNVERTEXATTRIB1FPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1f",2,0));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1FVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib1fv(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB1FVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1fv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1SPROC_HPP)(GLuint index,GLshort x);

static inline void VertexAttrib1s(GLuint index,GLshort x)
{
	static PFNVERTEXATTRIB1SPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1s",2,0));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1SVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib1sv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB1SVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1sv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2DPROC_HPP)(GLuint index,GLdouble x,GLdouble y);

static inline void VertexAttrib2d(GLuint index,GLdouble x,GLdouble y)
{
	static PFNVERTEXATTRIB2DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2d",2,0));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib2dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB2DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2dv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2FPROC_HPP)(GLuint index,GLfloat x,GLfloat y);

static inline void VertexAttrib2f(GLuint index,GLfloat x,GLfloat y)
{
	static PFNVERTEXATTRIB2FPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2f",2,0));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2FVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib2fv(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB2FVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2fv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2SPROC_HPP)(GLuint index,GLshort x,GLshort y);

static inline void VertexAttrib2s(GLuint index,GLshort x,GLshort y)
{
	static PFNVERTEXATTRIB2SPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2s",2,0));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2SVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib2sv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB2SVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2sv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3DPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexAttrib3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXATTRIB3DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3d",2,0));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib3dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB3DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3dv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3FPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z);

static inline void VertexAttrib3f(GLuint index,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNVERTEXATTRIB3FPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3f",2,0));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3FVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib3fv(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB3FVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3fv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3SPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z);

static inline void VertexAttrib3s(GLuint index,GLshort x,GLshort y,GLshort z)
{
	static PFNVERTEXATTRIB3SPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3s",2,0));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3SVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib3sv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB3SVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3sv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NBVPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttrib4Nbv(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIB4NBVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NBVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nbv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NIVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttrib4Niv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIB4NIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NIVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Niv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NSVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib4Nsv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB4NSVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NSVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nsv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUBPROC_HPP)(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);

static inline void VertexAttrib4Nub(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)
{
	static PFNVERTEXATTRIB4NUBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nub",2,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4NUBVPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttrib4Nubv(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIB4NUBVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUBVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nubv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttrib4Nuiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIB4NUIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUIVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nuiv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUSVPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttrib4Nusv(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIB4NUSVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUSVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4Nusv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4BVPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttrib4bv(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIB4BVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4BVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4bv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4DPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexAttrib4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXATTRIB4DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4d",2,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib4dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB4DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4dv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4FPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void VertexAttrib4f(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNVERTEXATTRIB4FPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4f",2,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4FVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib4fv(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB4FVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4fv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4IVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttrib4iv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIB4IVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4IVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4iv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4SPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);

static inline void VertexAttrib4s(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)
{
	static PFNVERTEXATTRIB4SPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4s",2,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4SVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib4sv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB4SVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4sv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4UBVPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttrib4ubv(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIB4UBVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UBVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4ubv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4UIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttrib4uiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIB4UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4uiv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4USVPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttrib4usv(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIB4USVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4USVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4usv",2,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBPOINTERPROC_HPP)(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribPointer(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBPOINTERPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBPOINTERPROC_HPP>(_impl::_get_proc_address("glVertexAttribPointer",2,0));
	 fn(index,size,type,normalized,stride,pointer);
}
#endif //(GLPROC_VERSION >= 20)
#if (GLPROC_VERSION >= 21)

#ifndef GL_VERSION_2_1

#define GL_VERSION_2_1
#ifndef GL_CURRENT_RASTER_SECONDARY_COLOR
#define GL_CURRENT_RASTER_SECONDARY_COLOR                               0x845F
#endif //GL_CURRENT_RASTER_SECONDARY_COLOR
#ifndef GL_PIXEL_PACK_BUFFER
#define GL_PIXEL_PACK_BUFFER                                            0x88EB
#endif //GL_PIXEL_PACK_BUFFER
#ifndef GL_PIXEL_UNPACK_BUFFER
#define GL_PIXEL_UNPACK_BUFFER                                          0x88EC
#endif //GL_PIXEL_UNPACK_BUFFER
#ifndef GL_PIXEL_PACK_BUFFER_BINDING
#define GL_PIXEL_PACK_BUFFER_BINDING                                    0x88ED
#endif //GL_PIXEL_PACK_BUFFER_BINDING
#ifndef GL_PIXEL_UNPACK_BUFFER_BINDING
#define GL_PIXEL_UNPACK_BUFFER_BINDING                                  0x88EF
#endif //GL_PIXEL_UNPACK_BUFFER_BINDING
#ifndef GL_SRGB
#define GL_SRGB                                                         0x8C40
#endif //GL_SRGB
#ifndef GL_SRGB8
#define GL_SRGB8                                                        0x8C41
#endif //GL_SRGB8
#ifndef GL_SRGB_ALPHA
#define GL_SRGB_ALPHA                                                   0x8C42
#endif //GL_SRGB_ALPHA
#ifndef GL_SRGB8_ALPHA8
#define GL_SRGB8_ALPHA8                                                 0x8C43
#endif //GL_SRGB8_ALPHA8
#ifndef GL_SLUMINANCE_ALPHA
#define GL_SLUMINANCE_ALPHA                                             0x8C44
#endif //GL_SLUMINANCE_ALPHA
#ifndef GL_SLUMINANCE8_ALPHA8
#define GL_SLUMINANCE8_ALPHA8                                           0x8C45
#endif //GL_SLUMINANCE8_ALPHA8
#ifndef GL_SLUMINANCE
#define GL_SLUMINANCE                                                   0x8C46
#endif //GL_SLUMINANCE
#ifndef GL_SLUMINANCE8
#define GL_SLUMINANCE8                                                  0x8C47
#endif //GL_SLUMINANCE8
#ifndef GL_COMPRESSED_SRGB
#define GL_COMPRESSED_SRGB                                              0x8C48
#endif //GL_COMPRESSED_SRGB
#ifndef GL_COMPRESSED_SRGB_ALPHA
#define GL_COMPRESSED_SRGB_ALPHA                                        0x8C49
#endif //GL_COMPRESSED_SRGB_ALPHA
#ifndef GL_COMPRESSED_SLUMINANCE
#define GL_COMPRESSED_SLUMINANCE                                        0x8C4A
#endif //GL_COMPRESSED_SLUMINANCE
#ifndef GL_COMPRESSED_SLUMINANCE_ALPHA
#define GL_COMPRESSED_SLUMINANCE_ALPHA                                  0x8C4B
#endif //GL_COMPRESSED_SLUMINANCE_ALPHA

#endif //GL_VERSION_2_1


typedef void (*PFNUNIFORMMATRIX2X3FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix2x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX2X3FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2X3FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2x3fv",2,1));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3X2FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix3x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX3X2FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3X2FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3x2fv",2,1));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX2X4FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix2x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX2X4FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2X4FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2x4fv",2,1));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4X2FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix4x2fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX4X2FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4X2FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4x2fv",2,1));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3X4FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix3x4fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX3X4FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3X4FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3x4fv",2,1));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4X3FVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix4x3fv(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX4X3FVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4X3FVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4x3fv",2,1));
	 fn(location,count,transpose,value);
}
#endif //(GLPROC_VERSION >= 21)
#if (GLPROC_VERSION >= 30)

#ifndef GL_VERSION_3_0

#define GL_VERSION_3_0
#ifndef GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT                          0x00000001
#endif //GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT
#ifndef GL_MAP_READ_BIT
#define GL_MAP_READ_BIT                                                 0x0001
#endif //GL_MAP_READ_BIT
#ifndef GL_MAP_WRITE_BIT
#define GL_MAP_WRITE_BIT                                                0x0002
#endif //GL_MAP_WRITE_BIT
#ifndef GL_MAP_INVALIDATE_RANGE_BIT
#define GL_MAP_INVALIDATE_RANGE_BIT                                     0x0004
#endif //GL_MAP_INVALIDATE_RANGE_BIT
#ifndef GL_MAP_INVALIDATE_BUFFER_BIT
#define GL_MAP_INVALIDATE_BUFFER_BIT                                    0x0008
#endif //GL_MAP_INVALIDATE_BUFFER_BIT
#ifndef GL_MAP_FLUSH_EXPLICIT_BIT
#define GL_MAP_FLUSH_EXPLICIT_BIT                                       0x0010
#endif //GL_MAP_FLUSH_EXPLICIT_BIT
#ifndef GL_MAP_UNSYNCHRONIZED_BIT
#define GL_MAP_UNSYNCHRONIZED_BIT                                       0x0020
#endif //GL_MAP_UNSYNCHRONIZED_BIT
#ifndef GL_CLIP_DISTANCE0
#define GL_CLIP_DISTANCE0                                               0x3000
#endif //GL_CLIP_DISTANCE0
#ifndef GL_CLIP_PLANE0
#define GL_CLIP_PLANE0                                                  0x3000
#endif //GL_CLIP_PLANE0
#ifndef GL_CLIP_PLANE1
#define GL_CLIP_PLANE1                                                  0x3001
#endif //GL_CLIP_PLANE1
#ifndef GL_CLIP_DISTANCE1
#define GL_CLIP_DISTANCE1                                               0x3001
#endif //GL_CLIP_DISTANCE1
#ifndef GL_CLIP_DISTANCE2
#define GL_CLIP_DISTANCE2                                               0x3002
#endif //GL_CLIP_DISTANCE2
#ifndef GL_CLIP_PLANE2
#define GL_CLIP_PLANE2                                                  0x3002
#endif //GL_CLIP_PLANE2
#ifndef GL_CLIP_PLANE3
#define GL_CLIP_PLANE3                                                  0x3003
#endif //GL_CLIP_PLANE3
#ifndef GL_CLIP_DISTANCE3
#define GL_CLIP_DISTANCE3                                               0x3003
#endif //GL_CLIP_DISTANCE3
#ifndef GL_CLIP_PLANE4
#define GL_CLIP_PLANE4                                                  0x3004
#endif //GL_CLIP_PLANE4
#ifndef GL_CLIP_DISTANCE4
#define GL_CLIP_DISTANCE4                                               0x3004
#endif //GL_CLIP_DISTANCE4
#ifndef GL_CLIP_DISTANCE5
#define GL_CLIP_DISTANCE5                                               0x3005
#endif //GL_CLIP_DISTANCE5
#ifndef GL_CLIP_DISTANCE6
#define GL_CLIP_DISTANCE6                                               0x3006
#endif //GL_CLIP_DISTANCE6
#ifndef GL_CLIP_PLANE5
#define GL_CLIP_PLANE5                                                  0x3007
#endif //GL_CLIP_PLANE5
#ifndef GL_CLIP_DISTANCE7
#define GL_CLIP_DISTANCE7                                               0x3007
#endif //GL_CLIP_DISTANCE7
#ifndef GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING                        0x8210
#endif //GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
#ifndef GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE
#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE                        0x8211
#endif //GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE                              0x8212
#endif //GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE                            0x8213
#endif //GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE                             0x8214
#endif //GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE                            0x8215
#endif //GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE                            0x8216
#endif //GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE                          0x8217
#endif //GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
#ifndef GL_FRAMEBUFFER_DEFAULT
#define GL_FRAMEBUFFER_DEFAULT                                          0x8218
#endif //GL_FRAMEBUFFER_DEFAULT
#ifndef GL_FRAMEBUFFER_UNDEFINED
#define GL_FRAMEBUFFER_UNDEFINED                                        0x8219
#endif //GL_FRAMEBUFFER_UNDEFINED
#ifndef GL_DEPTH_STENCIL_ATTACHMENT
#define GL_DEPTH_STENCIL_ATTACHMENT                                     0x821A
#endif //GL_DEPTH_STENCIL_ATTACHMENT
#ifndef GL_MAJOR_VERSION
#define GL_MAJOR_VERSION                                                0x821B
#endif //GL_MAJOR_VERSION
#ifndef GL_MINOR_VERSION
#define GL_MINOR_VERSION                                                0x821C
#endif //GL_MINOR_VERSION
#ifndef GL_NUM_EXTENSIONS
#define GL_NUM_EXTENSIONS                                               0x821D
#endif //GL_NUM_EXTENSIONS
#ifndef GL_CONTEXT_FLAGS
#define GL_CONTEXT_FLAGS                                                0x821E
#endif //GL_CONTEXT_FLAGS
#ifndef GL_INDEX
#define GL_INDEX                                                        0x8222
#endif //GL_INDEX
#ifndef GL_COMPRESSED_RED
#define GL_COMPRESSED_RED                                               0x8225
#endif //GL_COMPRESSED_RED
#ifndef GL_COMPRESSED_RG
#define GL_COMPRESSED_RG                                                0x8226
#endif //GL_COMPRESSED_RG
#ifndef GL_RG
#define GL_RG                                                           0x8227
#endif //GL_RG
#ifndef GL_RG_INTEGER
#define GL_RG_INTEGER                                                   0x8228
#endif //GL_RG_INTEGER
#ifndef GL_R8
#define GL_R8                                                           0x8229
#endif //GL_R8
#ifndef GL_R16
#define GL_R16                                                          0x822A
#endif //GL_R16
#ifndef GL_RG8
#define GL_RG8                                                          0x822B
#endif //GL_RG8
#ifndef GL_RG16
#define GL_RG16                                                         0x822C
#endif //GL_RG16
#ifndef GL_R16F
#define GL_R16F                                                         0x822D
#endif //GL_R16F
#ifndef GL_R32F
#define GL_R32F                                                         0x822E
#endif //GL_R32F
#ifndef GL_RG16F
#define GL_RG16F                                                        0x822F
#endif //GL_RG16F
#ifndef GL_RG32F
#define GL_RG32F                                                        0x8230
#endif //GL_RG32F
#ifndef GL_R8I
#define GL_R8I                                                          0x8231
#endif //GL_R8I
#ifndef GL_R8UI
#define GL_R8UI                                                         0x8232
#endif //GL_R8UI
#ifndef GL_R16I
#define GL_R16I                                                         0x8233
#endif //GL_R16I
#ifndef GL_R16UI
#define GL_R16UI                                                        0x8234
#endif //GL_R16UI
#ifndef GL_R32I
#define GL_R32I                                                         0x8235
#endif //GL_R32I
#ifndef GL_R32UI
#define GL_R32UI                                                        0x8236
#endif //GL_R32UI
#ifndef GL_RG8I
#define GL_RG8I                                                         0x8237
#endif //GL_RG8I
#ifndef GL_RG8UI
#define GL_RG8UI                                                        0x8238
#endif //GL_RG8UI
#ifndef GL_RG16I
#define GL_RG16I                                                        0x8239
#endif //GL_RG16I
#ifndef GL_RG16UI
#define GL_RG16UI                                                       0x823A
#endif //GL_RG16UI
#ifndef GL_RG32I
#define GL_RG32I                                                        0x823B
#endif //GL_RG32I
#ifndef GL_RG32UI
#define GL_RG32UI                                                       0x823C
#endif //GL_RG32UI
#ifndef GL_MAX_RENDERBUFFER_SIZE
#define GL_MAX_RENDERBUFFER_SIZE                                        0x84E8
#endif //GL_MAX_RENDERBUFFER_SIZE
#ifndef GL_DEPTH_STENCIL
#define GL_DEPTH_STENCIL                                                0x84F9
#endif //GL_DEPTH_STENCIL
#ifndef GL_UNSIGNED_INT_24_8
#define GL_UNSIGNED_INT_24_8                                            0x84FA
#endif //GL_UNSIGNED_INT_24_8
#ifndef GL_VERTEX_ARRAY_BINDING
#define GL_VERTEX_ARRAY_BINDING                                         0x85B5
#endif //GL_VERTEX_ARRAY_BINDING
#ifndef GL_RGBA32F
#define GL_RGBA32F                                                      0x8814
#endif //GL_RGBA32F
#ifndef GL_RGB32F
#define GL_RGB32F                                                       0x8815
#endif //GL_RGB32F
#ifndef GL_RGBA16F
#define GL_RGBA16F                                                      0x881A
#endif //GL_RGBA16F
#ifndef GL_RGB16F
#define GL_RGB16F                                                       0x881B
#endif //GL_RGB16F
#ifndef GL_COMPARE_R_TO_TEXTURE_ARB
#define GL_COMPARE_R_TO_TEXTURE_ARB                                     0x884E
#endif //GL_COMPARE_R_TO_TEXTURE_ARB
#ifndef GL_COMPARE_REF_TO_TEXTURE
#define GL_COMPARE_REF_TO_TEXTURE                                       0x884E
#endif //GL_COMPARE_REF_TO_TEXTURE
#ifndef GL_DEPTH24_STENCIL8
#define GL_DEPTH24_STENCIL8                                             0x88F0
#endif //GL_DEPTH24_STENCIL8
#ifndef GL_TEXTURE_STENCIL_SIZE
#define GL_TEXTURE_STENCIL_SIZE                                         0x88F1
#endif //GL_TEXTURE_STENCIL_SIZE
#ifndef GL_VERTEX_ATTRIB_ARRAY_INTEGER
#define GL_VERTEX_ATTRIB_ARRAY_INTEGER                                  0x88FD
#endif //GL_VERTEX_ATTRIB_ARRAY_INTEGER
#ifndef GL_MAX_ARRAY_TEXTURE_LAYERS
#define GL_MAX_ARRAY_TEXTURE_LAYERS                                     0x88FF
#endif //GL_MAX_ARRAY_TEXTURE_LAYERS
#ifndef GL_MIN_PROGRAM_TEXEL_OFFSET
#define GL_MIN_PROGRAM_TEXEL_OFFSET                                     0x8904
#endif //GL_MIN_PROGRAM_TEXEL_OFFSET
#ifndef GL_MAX_PROGRAM_TEXEL_OFFSET
#define GL_MAX_PROGRAM_TEXEL_OFFSET                                     0x8905
#endif //GL_MAX_PROGRAM_TEXEL_OFFSET
#ifndef GL_CLAMP_VERTEX_COLOR
#define GL_CLAMP_VERTEX_COLOR                                           0x891A
#endif //GL_CLAMP_VERTEX_COLOR
#ifndef GL_CLAMP_FRAGMENT_COLOR
#define GL_CLAMP_FRAGMENT_COLOR                                         0x891B
#endif //GL_CLAMP_FRAGMENT_COLOR
#ifndef GL_CLAMP_READ_COLOR
#define GL_CLAMP_READ_COLOR                                             0x891C
#endif //GL_CLAMP_READ_COLOR
#ifndef GL_FIXED_ONLY
#define GL_FIXED_ONLY                                                   0x891D
#endif //GL_FIXED_ONLY
#ifndef GL_MAX_VARYING_COMPONENTS
#define GL_MAX_VARYING_COMPONENTS                                       0x8B4B
#endif //GL_MAX_VARYING_COMPONENTS
#ifndef GL_MAX_VARYING_FLOATS
#define GL_MAX_VARYING_FLOATS                                           0x8B4B
#endif //GL_MAX_VARYING_FLOATS
#ifndef GL_TEXTURE_RED_TYPE
#define GL_TEXTURE_RED_TYPE                                             0x8C10
#endif //GL_TEXTURE_RED_TYPE
#ifndef GL_TEXTURE_GREEN_TYPE
#define GL_TEXTURE_GREEN_TYPE                                           0x8C11
#endif //GL_TEXTURE_GREEN_TYPE
#ifndef GL_TEXTURE_BLUE_TYPE
#define GL_TEXTURE_BLUE_TYPE                                            0x8C12
#endif //GL_TEXTURE_BLUE_TYPE
#ifndef GL_TEXTURE_ALPHA_TYPE
#define GL_TEXTURE_ALPHA_TYPE                                           0x8C13
#endif //GL_TEXTURE_ALPHA_TYPE
#ifndef GL_TEXTURE_LUMINANCE_TYPE
#define GL_TEXTURE_LUMINANCE_TYPE                                       0x8C14
#endif //GL_TEXTURE_LUMINANCE_TYPE
#ifndef GL_TEXTURE_INTENSITY_TYPE
#define GL_TEXTURE_INTENSITY_TYPE                                       0x8C15
#endif //GL_TEXTURE_INTENSITY_TYPE
#ifndef GL_TEXTURE_DEPTH_TYPE
#define GL_TEXTURE_DEPTH_TYPE                                           0x8C16
#endif //GL_TEXTURE_DEPTH_TYPE
#ifndef GL_UNSIGNED_NORMALIZED
#define GL_UNSIGNED_NORMALIZED                                          0x8C17
#endif //GL_UNSIGNED_NORMALIZED
#ifndef GL_TEXTURE_1D_ARRAY
#define GL_TEXTURE_1D_ARRAY                                             0x8C18
#endif //GL_TEXTURE_1D_ARRAY
#ifndef GL_PROXY_TEXTURE_1D_ARRAY
#define GL_PROXY_TEXTURE_1D_ARRAY                                       0x8C19
#endif //GL_PROXY_TEXTURE_1D_ARRAY
#ifndef GL_TEXTURE_2D_ARRAY
#define GL_TEXTURE_2D_ARRAY                                             0x8C1A
#endif //GL_TEXTURE_2D_ARRAY
#ifndef GL_PROXY_TEXTURE_2D_ARRAY
#define GL_PROXY_TEXTURE_2D_ARRAY                                       0x8C1B
#endif //GL_PROXY_TEXTURE_2D_ARRAY
#ifndef GL_TEXTURE_BINDING_1D_ARRAY
#define GL_TEXTURE_BINDING_1D_ARRAY                                     0x8C1C
#endif //GL_TEXTURE_BINDING_1D_ARRAY
#ifndef GL_TEXTURE_BINDING_2D_ARRAY
#define GL_TEXTURE_BINDING_2D_ARRAY                                     0x8C1D
#endif //GL_TEXTURE_BINDING_2D_ARRAY
#ifndef GL_R11F_G11F_B10F
#define GL_R11F_G11F_B10F                                               0x8C3A
#endif //GL_R11F_G11F_B10F
#ifndef GL_UNSIGNED_INT_10F_11F_11F_REV
#define GL_UNSIGNED_INT_10F_11F_11F_REV                                 0x8C3B
#endif //GL_UNSIGNED_INT_10F_11F_11F_REV
#ifndef GL_RGB9_E5
#define GL_RGB9_E5                                                      0x8C3D
#endif //GL_RGB9_E5
#ifndef GL_UNSIGNED_INT_5_9_9_9_REV
#define GL_UNSIGNED_INT_5_9_9_9_REV                                     0x8C3E
#endif //GL_UNSIGNED_INT_5_9_9_9_REV
#ifndef GL_TEXTURE_SHARED_SIZE
#define GL_TEXTURE_SHARED_SIZE                                          0x8C3F
#endif //GL_TEXTURE_SHARED_SIZE
#ifndef GL_DRAW_FRAMEBUFFER_BINDING
#define GL_DRAW_FRAMEBUFFER_BINDING                                     0x8CA6
#endif //GL_DRAW_FRAMEBUFFER_BINDING
#ifndef GL_FRAMEBUFFER_BINDING
#define GL_FRAMEBUFFER_BINDING                                          0x8CA6
#endif //GL_FRAMEBUFFER_BINDING
#ifndef GL_RENDERBUFFER_BINDING
#define GL_RENDERBUFFER_BINDING                                         0x8CA7
#endif //GL_RENDERBUFFER_BINDING
#ifndef GL_READ_FRAMEBUFFER
#define GL_READ_FRAMEBUFFER                                             0x8CA8
#endif //GL_READ_FRAMEBUFFER
#ifndef GL_DRAW_FRAMEBUFFER
#define GL_DRAW_FRAMEBUFFER                                             0x8CA9
#endif //GL_DRAW_FRAMEBUFFER
#ifndef GL_READ_FRAMEBUFFER_BINDING
#define GL_READ_FRAMEBUFFER_BINDING                                     0x8CAA
#endif //GL_READ_FRAMEBUFFER_BINDING
#ifndef GL_RENDERBUFFER_SAMPLES
#define GL_RENDERBUFFER_SAMPLES                                         0x8CAB
#endif //GL_RENDERBUFFER_SAMPLES
#ifndef GL_SAMPLER_1D_ARRAY
#define GL_SAMPLER_1D_ARRAY                                             0x8DC0
#endif //GL_SAMPLER_1D_ARRAY
#ifndef GL_SAMPLER_2D_ARRAY
#define GL_SAMPLER_2D_ARRAY                                             0x8DC1
#endif //GL_SAMPLER_2D_ARRAY
#ifndef GL_SAMPLER_1D_ARRAY_SHADOW
#define GL_SAMPLER_1D_ARRAY_SHADOW                                      0x8DC3
#endif //GL_SAMPLER_1D_ARRAY_SHADOW
#ifndef GL_SAMPLER_2D_ARRAY_SHADOW
#define GL_SAMPLER_2D_ARRAY_SHADOW                                      0x8DC4
#endif //GL_SAMPLER_2D_ARRAY_SHADOW
#ifndef GL_SAMPLER_CUBE_SHADOW
#define GL_SAMPLER_CUBE_SHADOW                                          0x8DC5
#endif //GL_SAMPLER_CUBE_SHADOW
#ifndef GL_UNSIGNED_INT_VEC2
#define GL_UNSIGNED_INT_VEC2                                            0x8DC6
#endif //GL_UNSIGNED_INT_VEC2
#ifndef GL_UNSIGNED_INT_VEC3
#define GL_UNSIGNED_INT_VEC3                                            0x8DC7
#endif //GL_UNSIGNED_INT_VEC3
#ifndef GL_UNSIGNED_INT_VEC4
#define GL_UNSIGNED_INT_VEC4                                            0x8DC8
#endif //GL_UNSIGNED_INT_VEC4
#ifndef GL_INT_SAMPLER_1D
#define GL_INT_SAMPLER_1D                                               0x8DC9
#endif //GL_INT_SAMPLER_1D
#ifndef GL_INT_SAMPLER_2D
#define GL_INT_SAMPLER_2D                                               0x8DCA
#endif //GL_INT_SAMPLER_2D
#ifndef GL_INT_SAMPLER_3D
#define GL_INT_SAMPLER_3D                                               0x8DCB
#endif //GL_INT_SAMPLER_3D
#ifndef GL_INT_SAMPLER_CUBE
#define GL_INT_SAMPLER_CUBE                                             0x8DCC
#endif //GL_INT_SAMPLER_CUBE
#ifndef GL_INT_SAMPLER_1D_ARRAY
#define GL_INT_SAMPLER_1D_ARRAY                                         0x8DCE
#endif //GL_INT_SAMPLER_1D_ARRAY
#ifndef GL_INT_SAMPLER_2D_ARRAY
#define GL_INT_SAMPLER_2D_ARRAY                                         0x8DCF
#endif //GL_INT_SAMPLER_2D_ARRAY
#ifndef GL_UNSIGNED_INT_SAMPLER_1D
#define GL_UNSIGNED_INT_SAMPLER_1D                                      0x8DD1
#endif //GL_UNSIGNED_INT_SAMPLER_1D
#ifndef GL_UNSIGNED_INT_SAMPLER_2D
#define GL_UNSIGNED_INT_SAMPLER_2D                                      0x8DD2
#endif //GL_UNSIGNED_INT_SAMPLER_2D
#ifndef GL_UNSIGNED_INT_SAMPLER_3D
#define GL_UNSIGNED_INT_SAMPLER_3D                                      0x8DD3
#endif //GL_UNSIGNED_INT_SAMPLER_3D
#ifndef GL_UNSIGNED_INT_SAMPLER_CUBE
#define GL_UNSIGNED_INT_SAMPLER_CUBE                                    0x8DD4
#endif //GL_UNSIGNED_INT_SAMPLER_CUBE
#ifndef GL_UNSIGNED_INT_SAMPLER_1D_ARRAY
#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY                                0x8DD6
#endif //GL_UNSIGNED_INT_SAMPLER_1D_ARRAY
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_ARRAY
#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY                                0x8DD7
#endif //GL_UNSIGNED_INT_SAMPLER_2D_ARRAY
#ifndef GL_QUERY_WAIT
#define GL_QUERY_WAIT                                                   0x8E13
#endif //GL_QUERY_WAIT
#ifndef GL_QUERY_NO_WAIT
#define GL_QUERY_NO_WAIT                                                0x8E14
#endif //GL_QUERY_NO_WAIT
#ifndef GL_QUERY_BY_REGION_WAIT
#define GL_QUERY_BY_REGION_WAIT                                         0x8E15
#endif //GL_QUERY_BY_REGION_WAIT
#ifndef GL_QUERY_BY_REGION_NO_WAIT
#define GL_QUERY_BY_REGION_NO_WAIT                                      0x8E16
#endif //GL_QUERY_BY_REGION_NO_WAIT
#ifndef GL_BUFFER_ACCESS_FLAGS
#define GL_BUFFER_ACCESS_FLAGS                                          0x911F
#endif //GL_BUFFER_ACCESS_FLAGS
#ifndef GL_BUFFER_MAP_LENGTH
#define GL_BUFFER_MAP_LENGTH                                            0x9120
#endif //GL_BUFFER_MAP_LENGTH
#ifndef GL_BUFFER_MAP_OFFSET
#define GL_BUFFER_MAP_OFFSET                                            0x9121
#endif //GL_BUFFER_MAP_OFFSET

#endif //GL_VERSION_3_0


typedef void (*PFNCOLORMASKIPROC_HPP)(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a);

static inline void ColorMaski(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)
{
	static PFNCOLORMASKIPROC_HPP fn=reinterpret_cast<PFNCOLORMASKIPROC_HPP>(_impl::_get_proc_address("glColorMaski",3,0));
	 fn(index,r,g,b,a);
}

typedef void (*PFNGETBOOLEANI_VPROC_HPP)(GLenum target,GLuint index,GLboolean *data);

static inline void GetBooleani_v(GLenum target,GLuint index,GLboolean *data)
{
	static PFNGETBOOLEANI_VPROC_HPP fn=reinterpret_cast<PFNGETBOOLEANI_VPROC_HPP>(_impl::_get_proc_address("glGetBooleani_v",3,0));
	 fn(target,index,data);
}

typedef void (*PFNGETINTEGERI_VPROC_HPP)(GLenum target,GLuint index,GLint *data);

static inline void GetIntegeri_v(GLenum target,GLuint index,GLint *data)
{
	static PFNGETINTEGERI_VPROC_HPP fn=reinterpret_cast<PFNGETINTEGERI_VPROC_HPP>(_impl::_get_proc_address("glGetIntegeri_v",3,0));
	 fn(target,index,data);
}

typedef void (*PFNENABLEIPROC_HPP)(GLenum target,GLuint index);

static inline void Enablei(GLenum target,GLuint index)
{
	static PFNENABLEIPROC_HPP fn=reinterpret_cast<PFNENABLEIPROC_HPP>(_impl::_get_proc_address("glEnablei",3,0));
	 fn(target,index);
}

typedef void (*PFNDISABLEIPROC_HPP)(GLenum target,GLuint index);

static inline void Disablei(GLenum target,GLuint index)
{
	static PFNDISABLEIPROC_HPP fn=reinterpret_cast<PFNDISABLEIPROC_HPP>(_impl::_get_proc_address("glDisablei",3,0));
	 fn(target,index);
}

typedef GLboolean (*PFNISENABLEDIPROC_HPP)(GLenum target,GLuint index);

static inline GLboolean IsEnabledi(GLenum target,GLuint index)
{
	static PFNISENABLEDIPROC_HPP fn=reinterpret_cast<PFNISENABLEDIPROC_HPP>(_impl::_get_proc_address("glIsEnabledi",3,0));
	return fn(target,index);
}

typedef void (*PFNBEGINTRANSFORMFEEDBACKPROC_HPP)(GLenum primitiveMode);

static inline void BeginTransformFeedback(GLenum primitiveMode)
{
	static PFNBEGINTRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNBEGINTRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glBeginTransformFeedback",3,0));
	 fn(primitiveMode);
}

typedef void (*PFNENDTRANSFORMFEEDBACKPROC_HPP)();

static inline void EndTransformFeedback()
{
	static PFNENDTRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNENDTRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glEndTransformFeedback",3,0));
	 fn();
}

typedef void (*PFNBINDBUFFERRANGEPROC_HPP)(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);

static inline void BindBufferRange(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)
{
	static PFNBINDBUFFERRANGEPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERRANGEPROC_HPP>(_impl::_get_proc_address("glBindBufferRange",3,0));
	 fn(target,index,buffer,offset,size);
}

typedef void (*PFNBINDBUFFERBASEPROC_HPP)(GLenum target,GLuint index,GLuint buffer);

static inline void BindBufferBase(GLenum target,GLuint index,GLuint buffer)
{
	static PFNBINDBUFFERBASEPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERBASEPROC_HPP>(_impl::_get_proc_address("glBindBufferBase",3,0));
	 fn(target,index,buffer);
}

typedef void (*PFNTRANSFORMFEEDBACKVARYINGSPROC_HPP)(GLuint program,GLsizei count,const GLchar* const *varyings,GLenum bufferMode);

static inline void TransformFeedbackVaryings(GLuint program,GLsizei count,const GLchar* const *varyings,GLenum bufferMode)
{
	static PFNTRANSFORMFEEDBACKVARYINGSPROC_HPP fn=reinterpret_cast<PFNTRANSFORMFEEDBACKVARYINGSPROC_HPP>(_impl::_get_proc_address("glTransformFeedbackVaryings",3,0));
	 fn(program,count,varyings,bufferMode);
}

typedef void (*PFNGETTRANSFORMFEEDBACKVARYINGPROC_HPP)(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name);

static inline void GetTransformFeedbackVarying(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name)
{
	static PFNGETTRANSFORMFEEDBACKVARYINGPROC_HPP fn=reinterpret_cast<PFNGETTRANSFORMFEEDBACKVARYINGPROC_HPP>(_impl::_get_proc_address("glGetTransformFeedbackVarying",3,0));
	 fn(program,index,bufSize,length,size,type,name);
}

typedef void (*PFNCLAMPCOLORPROC_HPP)(GLenum target,GLenum clamp);

static inline void ClampColor(GLenum target,GLenum clamp)
{
	static PFNCLAMPCOLORPROC_HPP fn=reinterpret_cast<PFNCLAMPCOLORPROC_HPP>(_impl::_get_proc_address("glClampColor",3,0));
	 fn(target,clamp);
}

typedef void (*PFNBEGINCONDITIONALRENDERPROC_HPP)(GLuint id,GLenum mode);

static inline void BeginConditionalRender(GLuint id,GLenum mode)
{
	static PFNBEGINCONDITIONALRENDERPROC_HPP fn=reinterpret_cast<PFNBEGINCONDITIONALRENDERPROC_HPP>(_impl::_get_proc_address("glBeginConditionalRender",3,0));
	 fn(id,mode);
}

typedef void (*PFNENDCONDITIONALRENDERPROC_HPP)();

static inline void EndConditionalRender()
{
	static PFNENDCONDITIONALRENDERPROC_HPP fn=reinterpret_cast<PFNENDCONDITIONALRENDERPROC_HPP>(_impl::_get_proc_address("glEndConditionalRender",3,0));
	 fn();
}

typedef void (*PFNVERTEXATTRIBIPOINTERPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribIPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBIPOINTERPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBIPOINTERPROC_HPP>(_impl::_get_proc_address("glVertexAttribIPointer",3,0));
	 fn(index,size,type,stride,pointer);
}

typedef void (*PFNGETVERTEXATTRIBIIVPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribIiv(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBIIVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIIVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribIiv",3,0));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBIUIVPROC_HPP)(GLuint index,GLenum pname,GLuint *params);

static inline void GetVertexAttribIuiv(GLuint index,GLenum pname,GLuint *params)
{
	static PFNGETVERTEXATTRIBIUIVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIUIVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribIuiv",3,0));
	 fn(index,pname,params);
}

typedef void (*PFNVERTEXATTRIBI1IPROC_HPP)(GLuint index,GLint x);

static inline void VertexAttribI1i(GLuint index,GLint x)
{
	static PFNVERTEXATTRIBI1IPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1IPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1i",3,0));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBI2IPROC_HPP)(GLuint index,GLint x,GLint y);

static inline void VertexAttribI2i(GLuint index,GLint x,GLint y)
{
	static PFNVERTEXATTRIBI2IPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2IPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2i",3,0));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBI3IPROC_HPP)(GLuint index,GLint x,GLint y,GLint z);

static inline void VertexAttribI3i(GLuint index,GLint x,GLint y,GLint z)
{
	static PFNVERTEXATTRIBI3IPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3IPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3i",3,0));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBI4IPROC_HPP)(GLuint index,GLint x,GLint y,GLint z,GLint w);

static inline void VertexAttribI4i(GLuint index,GLint x,GLint y,GLint z,GLint w)
{
	static PFNVERTEXATTRIBI4IPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4IPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4i",3,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBI1UIPROC_HPP)(GLuint index,GLuint x);

static inline void VertexAttribI1ui(GLuint index,GLuint x)
{
	static PFNVERTEXATTRIBI1UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1ui",3,0));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBI2UIPROC_HPP)(GLuint index,GLuint x,GLuint y);

static inline void VertexAttribI2ui(GLuint index,GLuint x,GLuint y)
{
	static PFNVERTEXATTRIBI2UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2ui",3,0));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBI3UIPROC_HPP)(GLuint index,GLuint x,GLuint y,GLuint z);

static inline void VertexAttribI3ui(GLuint index,GLuint x,GLuint y,GLuint z)
{
	static PFNVERTEXATTRIBI3UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3ui",3,0));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBI4UIPROC_HPP)(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);

static inline void VertexAttribI4ui(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)
{
	static PFNVERTEXATTRIBI4UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4ui",3,0));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBI1IVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI1iv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI1IVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1IVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1iv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI2IVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI2iv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI2IVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2IVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2iv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI3IVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI3iv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI3IVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3IVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3iv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4IVPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI4iv(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI4IVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4IVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4iv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI1UIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI1uiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI1UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1uiv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI2UIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI2uiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI2UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2uiv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI3UIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI3uiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI3UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3uiv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4UIVPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI4uiv(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI4UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4uiv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4BVPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttribI4bv(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIBI4BVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4BVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4bv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4SVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttribI4sv(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIBI4SVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4SVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4sv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4UBVPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttribI4ubv(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIBI4UBVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UBVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4ubv",3,0));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4USVPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttribI4usv(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIBI4USVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4USVPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4usv",3,0));
	 fn(index,v);
}

typedef void (*PFNGETUNIFORMUIVPROC_HPP)(GLuint program,GLint location,GLuint *params);

static inline void GetUniformuiv(GLuint program,GLint location,GLuint *params)
{
	static PFNGETUNIFORMUIVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMUIVPROC_HPP>(_impl::_get_proc_address("glGetUniformuiv",3,0));
	 fn(program,location,params);
}

typedef void (*PFNBINDFRAGDATALOCATIONPROC_HPP)(GLuint program,GLuint color,const GLchar *name);

static inline void BindFragDataLocation(GLuint program,GLuint color,const GLchar *name)
{
	static PFNBINDFRAGDATALOCATIONPROC_HPP fn=reinterpret_cast<PFNBINDFRAGDATALOCATIONPROC_HPP>(_impl::_get_proc_address("glBindFragDataLocation",3,0));
	 fn(program,color,name);
}

typedef GLint (*PFNGETFRAGDATALOCATIONPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetFragDataLocation(GLuint program,const GLchar *name)
{
	static PFNGETFRAGDATALOCATIONPROC_HPP fn=reinterpret_cast<PFNGETFRAGDATALOCATIONPROC_HPP>(_impl::_get_proc_address("glGetFragDataLocation",3,0));
	return fn(program,name);
}

typedef void (*PFNUNIFORM1UIPROC_HPP)(GLint location,GLuint v0);

static inline void Uniform1ui(GLint location,GLuint v0)
{
	static PFNUNIFORM1UIPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UIPROC_HPP>(_impl::_get_proc_address("glUniform1ui",3,0));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2UIPROC_HPP)(GLint location,GLuint v0,GLuint v1);

static inline void Uniform2ui(GLint location,GLuint v0,GLuint v1)
{
	static PFNUNIFORM2UIPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UIPROC_HPP>(_impl::_get_proc_address("glUniform2ui",3,0));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3UIPROC_HPP)(GLint location,GLuint v0,GLuint v1,GLuint v2);

static inline void Uniform3ui(GLint location,GLuint v0,GLuint v1,GLuint v2)
{
	static PFNUNIFORM3UIPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UIPROC_HPP>(_impl::_get_proc_address("glUniform3ui",3,0));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4UIPROC_HPP)(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);

static inline void Uniform4ui(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)
{
	static PFNUNIFORM4UIPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UIPROC_HPP>(_impl::_get_proc_address("glUniform4ui",3,0));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1UIVPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform1uiv(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM1UIVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UIVPROC_HPP>(_impl::_get_proc_address("glUniform1uiv",3,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2UIVPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform2uiv(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM2UIVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UIVPROC_HPP>(_impl::_get_proc_address("glUniform2uiv",3,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3UIVPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform3uiv(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM3UIVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UIVPROC_HPP>(_impl::_get_proc_address("glUniform3uiv",3,0));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4UIVPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform4uiv(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM4UIVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UIVPROC_HPP>(_impl::_get_proc_address("glUniform4uiv",3,0));
	 fn(location,count,value);
}

typedef void (*PFNTEXPARAMETERIIVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void TexParameterIiv(GLenum target,GLenum pname,const GLint *params)
{
	static PFNTEXPARAMETERIIVPROC_HPP fn=reinterpret_cast<PFNTEXPARAMETERIIVPROC_HPP>(_impl::_get_proc_address("glTexParameterIiv",3,0));
	 fn(target,pname,params);
}

typedef void (*PFNTEXPARAMETERIUIVPROC_HPP)(GLenum target,GLenum pname,const GLuint *params);

static inline void TexParameterIuiv(GLenum target,GLenum pname,const GLuint *params)
{
	static PFNTEXPARAMETERIUIVPROC_HPP fn=reinterpret_cast<PFNTEXPARAMETERIUIVPROC_HPP>(_impl::_get_proc_address("glTexParameterIuiv",3,0));
	 fn(target,pname,params);
}

typedef void (*PFNGETTEXPARAMETERIIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetTexParameterIiv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETTEXPARAMETERIIVPROC_HPP fn=reinterpret_cast<PFNGETTEXPARAMETERIIVPROC_HPP>(_impl::_get_proc_address("glGetTexParameterIiv",3,0));
	 fn(target,pname,params);
}

typedef void (*PFNGETTEXPARAMETERIUIVPROC_HPP)(GLenum target,GLenum pname,GLuint *params);

static inline void GetTexParameterIuiv(GLenum target,GLenum pname,GLuint *params)
{
	static PFNGETTEXPARAMETERIUIVPROC_HPP fn=reinterpret_cast<PFNGETTEXPARAMETERIUIVPROC_HPP>(_impl::_get_proc_address("glGetTexParameterIuiv",3,0));
	 fn(target,pname,params);
}

typedef void (*PFNCLEARBUFFERIVPROC_HPP)(GLenum buffer,GLint drawbuffer,const GLint *value);

static inline void ClearBufferiv(GLenum buffer,GLint drawbuffer,const GLint *value)
{
	static PFNCLEARBUFFERIVPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERIVPROC_HPP>(_impl::_get_proc_address("glClearBufferiv",3,0));
	 fn(buffer,drawbuffer,value);
}

typedef void (*PFNCLEARBUFFERUIVPROC_HPP)(GLenum buffer,GLint drawbuffer,const GLuint *value);

static inline void ClearBufferuiv(GLenum buffer,GLint drawbuffer,const GLuint *value)
{
	static PFNCLEARBUFFERUIVPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERUIVPROC_HPP>(_impl::_get_proc_address("glClearBufferuiv",3,0));
	 fn(buffer,drawbuffer,value);
}

typedef void (*PFNCLEARBUFFERFVPROC_HPP)(GLenum buffer,GLint drawbuffer,const GLfloat *value);

static inline void ClearBufferfv(GLenum buffer,GLint drawbuffer,const GLfloat *value)
{
	static PFNCLEARBUFFERFVPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERFVPROC_HPP>(_impl::_get_proc_address("glClearBufferfv",3,0));
	 fn(buffer,drawbuffer,value);
}

typedef void (*PFNCLEARBUFFERFIPROC_HPP)(GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil);

static inline void ClearBufferfi(GLenum buffer,GLint drawbuffer,GLfloat depth,GLint stencil)
{
	static PFNCLEARBUFFERFIPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERFIPROC_HPP>(_impl::_get_proc_address("glClearBufferfi",3,0));
	 fn(buffer,drawbuffer,depth,stencil);
}

typedef const GLubyte * (*PFNGETSTRINGIPROC_HPP)(GLenum name,GLuint index);

static inline const GLubyte * GetStringi(GLenum name,GLuint index)
{
	static PFNGETSTRINGIPROC_HPP fn=reinterpret_cast<PFNGETSTRINGIPROC_HPP>(_impl::_get_proc_address("glGetStringi",3,0));
	return fn(name,index);
}
#endif //(GLPROC_VERSION >= 30)
#if (GLPROC_VERSION >= 31)

#ifndef GL_VERSION_3_1

#define GL_VERSION_3_1
#ifndef GL_TEXTURE_RECTANGLE
#define GL_TEXTURE_RECTANGLE                                            0x84F5
#endif //GL_TEXTURE_RECTANGLE
#ifndef GL_TEXTURE_BINDING_RECTANGLE
#define GL_TEXTURE_BINDING_RECTANGLE                                    0x84F6
#endif //GL_TEXTURE_BINDING_RECTANGLE
#ifndef GL_PROXY_TEXTURE_RECTANGLE
#define GL_PROXY_TEXTURE_RECTANGLE                                      0x84F7
#endif //GL_PROXY_TEXTURE_RECTANGLE
#ifndef GL_MAX_RECTANGLE_TEXTURE_SIZE
#define GL_MAX_RECTANGLE_TEXTURE_SIZE                                   0x84F8
#endif //GL_MAX_RECTANGLE_TEXTURE_SIZE
#ifndef GL_UNIFORM_BUFFER
#define GL_UNIFORM_BUFFER                                               0x8A11
#endif //GL_UNIFORM_BUFFER
#ifndef GL_UNIFORM_BUFFER_BINDING
#define GL_UNIFORM_BUFFER_BINDING                                       0x8A28
#endif //GL_UNIFORM_BUFFER_BINDING
#ifndef GL_UNIFORM_BUFFER_START
#define GL_UNIFORM_BUFFER_START                                         0x8A29
#endif //GL_UNIFORM_BUFFER_START
#ifndef GL_UNIFORM_BUFFER_SIZE
#define GL_UNIFORM_BUFFER_SIZE                                          0x8A2A
#endif //GL_UNIFORM_BUFFER_SIZE
#ifndef GL_MAX_VERTEX_UNIFORM_BLOCKS
#define GL_MAX_VERTEX_UNIFORM_BLOCKS                                    0x8A2B
#endif //GL_MAX_VERTEX_UNIFORM_BLOCKS
#ifndef GL_MAX_GEOMETRY_UNIFORM_BLOCKS
#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS                                  0x8A2C
#endif //GL_MAX_GEOMETRY_UNIFORM_BLOCKS
#ifndef GL_MAX_FRAGMENT_UNIFORM_BLOCKS
#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS                                  0x8A2D
#endif //GL_MAX_FRAGMENT_UNIFORM_BLOCKS
#ifndef GL_MAX_COMBINED_UNIFORM_BLOCKS
#define GL_MAX_COMBINED_UNIFORM_BLOCKS                                  0x8A2E
#endif //GL_MAX_COMBINED_UNIFORM_BLOCKS
#ifndef GL_MAX_UNIFORM_BUFFER_BINDINGS
#define GL_MAX_UNIFORM_BUFFER_BINDINGS                                  0x8A2F
#endif //GL_MAX_UNIFORM_BUFFER_BINDINGS
#ifndef GL_MAX_UNIFORM_BLOCK_SIZE
#define GL_MAX_UNIFORM_BLOCK_SIZE                                       0x8A30
#endif //GL_MAX_UNIFORM_BLOCK_SIZE
#ifndef GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS                       0x8A31
#endif //GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS
#ifndef GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS                     0x8A32
#endif //GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS
#ifndef GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS                     0x8A33
#endif //GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
#ifndef GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT
#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT                              0x8A34
#endif //GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT
#ifndef GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH                         0x8A35
#endif //GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
#ifndef GL_ACTIVE_UNIFORM_BLOCKS
#define GL_ACTIVE_UNIFORM_BLOCKS                                        0x8A36
#endif //GL_ACTIVE_UNIFORM_BLOCKS
#ifndef GL_UNIFORM_TYPE
#define GL_UNIFORM_TYPE                                                 0x8A37
#endif //GL_UNIFORM_TYPE
#ifndef GL_UNIFORM_SIZE
#define GL_UNIFORM_SIZE                                                 0x8A38
#endif //GL_UNIFORM_SIZE
#ifndef GL_UNIFORM_NAME_LENGTH
#define GL_UNIFORM_NAME_LENGTH                                          0x8A39
#endif //GL_UNIFORM_NAME_LENGTH
#ifndef GL_UNIFORM_BLOCK_INDEX
#define GL_UNIFORM_BLOCK_INDEX                                          0x8A3A
#endif //GL_UNIFORM_BLOCK_INDEX
#ifndef GL_UNIFORM_OFFSET
#define GL_UNIFORM_OFFSET                                               0x8A3B
#endif //GL_UNIFORM_OFFSET
#ifndef GL_UNIFORM_ARRAY_STRIDE
#define GL_UNIFORM_ARRAY_STRIDE                                         0x8A3C
#endif //GL_UNIFORM_ARRAY_STRIDE
#ifndef GL_UNIFORM_MATRIX_STRIDE
#define GL_UNIFORM_MATRIX_STRIDE                                        0x8A3D
#endif //GL_UNIFORM_MATRIX_STRIDE
#ifndef GL_UNIFORM_IS_ROW_MAJOR
#define GL_UNIFORM_IS_ROW_MAJOR                                         0x8A3E
#endif //GL_UNIFORM_IS_ROW_MAJOR
#ifndef GL_UNIFORM_BLOCK_BINDING
#define GL_UNIFORM_BLOCK_BINDING                                        0x8A3F
#endif //GL_UNIFORM_BLOCK_BINDING
#ifndef GL_UNIFORM_BLOCK_DATA_SIZE
#define GL_UNIFORM_BLOCK_DATA_SIZE                                      0x8A40
#endif //GL_UNIFORM_BLOCK_DATA_SIZE
#ifndef GL_UNIFORM_BLOCK_NAME_LENGTH
#define GL_UNIFORM_BLOCK_NAME_LENGTH                                    0x8A41
#endif //GL_UNIFORM_BLOCK_NAME_LENGTH
#ifndef GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS                                0x8A42
#endif //GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS
#ifndef GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES                         0x8A43
#endif //GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER                    0x8A44
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER                  0x8A45
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER                  0x8A46
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER
#ifndef GL_SAMPLER_2D_RECT
#define GL_SAMPLER_2D_RECT                                              0x8B63
#endif //GL_SAMPLER_2D_RECT
#ifndef GL_SAMPLER_2D_RECT_SHADOW
#define GL_SAMPLER_2D_RECT_SHADOW                                       0x8B64
#endif //GL_SAMPLER_2D_RECT_SHADOW
#ifndef GL_TEXTURE_BUFFER
#define GL_TEXTURE_BUFFER                                               0x8C2A
#endif //GL_TEXTURE_BUFFER
#ifndef GL_MAX_TEXTURE_BUFFER_SIZE
#define GL_MAX_TEXTURE_BUFFER_SIZE                                      0x8C2B
#endif //GL_MAX_TEXTURE_BUFFER_SIZE
#ifndef GL_TEXTURE_BINDING_BUFFER
#define GL_TEXTURE_BINDING_BUFFER                                       0x8C2C
#endif //GL_TEXTURE_BINDING_BUFFER
#ifndef GL_TEXTURE_BUFFER_DATA_STORE_BINDING
#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING                            0x8C2D
#endif //GL_TEXTURE_BUFFER_DATA_STORE_BINDING
#ifndef GL_SAMPLER_BUFFER
#define GL_SAMPLER_BUFFER                                               0x8DC2
#endif //GL_SAMPLER_BUFFER
#ifndef GL_INT_SAMPLER_2D_RECT
#define GL_INT_SAMPLER_2D_RECT                                          0x8DCD
#endif //GL_INT_SAMPLER_2D_RECT
#ifndef GL_INT_SAMPLER_BUFFER
#define GL_INT_SAMPLER_BUFFER                                           0x8DD0
#endif //GL_INT_SAMPLER_BUFFER
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_RECT
#define GL_UNSIGNED_INT_SAMPLER_2D_RECT                                 0x8DD5
#endif //GL_UNSIGNED_INT_SAMPLER_2D_RECT
#ifndef GL_UNSIGNED_INT_SAMPLER_BUFFER
#define GL_UNSIGNED_INT_SAMPLER_BUFFER                                  0x8DD8
#endif //GL_UNSIGNED_INT_SAMPLER_BUFFER
#ifndef GL_COPY_READ_BUFFER
#define GL_COPY_READ_BUFFER                                             0x8F36
#endif //GL_COPY_READ_BUFFER
#ifndef GL_COPY_WRITE_BUFFER
#define GL_COPY_WRITE_BUFFER                                            0x8F37
#endif //GL_COPY_WRITE_BUFFER
#ifndef GL_RED_SNORM
#define GL_RED_SNORM                                                    0x8F90
#endif //GL_RED_SNORM
#ifndef GL_RG_SNORM
#define GL_RG_SNORM                                                     0x8F91
#endif //GL_RG_SNORM
#ifndef GL_RGB_SNORM
#define GL_RGB_SNORM                                                    0x8F92
#endif //GL_RGB_SNORM
#ifndef GL_RGBA_SNORM
#define GL_RGBA_SNORM                                                   0x8F93
#endif //GL_RGBA_SNORM
#ifndef GL_R8_SNORM
#define GL_R8_SNORM                                                     0x8F94
#endif //GL_R8_SNORM
#ifndef GL_RG8_SNORM
#define GL_RG8_SNORM                                                    0x8F95
#endif //GL_RG8_SNORM
#ifndef GL_RGB8_SNORM
#define GL_RGB8_SNORM                                                   0x8F96
#endif //GL_RGB8_SNORM
#ifndef GL_RGBA8_SNORM
#define GL_RGBA8_SNORM                                                  0x8F97
#endif //GL_RGBA8_SNORM
#ifndef GL_R16_SNORM
#define GL_R16_SNORM                                                    0x8F98
#endif //GL_R16_SNORM
#ifndef GL_RG16_SNORM
#define GL_RG16_SNORM                                                   0x8F99
#endif //GL_RG16_SNORM
#ifndef GL_RGB16_SNORM
#define GL_RGB16_SNORM                                                  0x8F9A
#endif //GL_RGB16_SNORM
#ifndef GL_RGBA16_SNORM
#define GL_RGBA16_SNORM                                                 0x8F9B
#endif //GL_RGBA16_SNORM
#ifndef GL_SIGNED_NORMALIZED
#define GL_SIGNED_NORMALIZED                                            0x8F9C
#endif //GL_SIGNED_NORMALIZED
#ifndef GL_PRIMITIVE_RESTART
#define GL_PRIMITIVE_RESTART                                            0x8F9D
#endif //GL_PRIMITIVE_RESTART
#ifndef GL_PRIMITIVE_RESTART_INDEX
#define GL_PRIMITIVE_RESTART_INDEX                                      0x8F9E
#endif //GL_PRIMITIVE_RESTART_INDEX
#ifndef GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS
#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS                        0x8F9F
#endif //GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS
#ifndef GL_INVALID_INDEX
#define GL_INVALID_INDEX                                                0xFFFFFFFF
#endif //GL_INVALID_INDEX

#endif //GL_VERSION_3_1


typedef void (*PFNDRAWARRAYSINSTANCEDPROC_HPP)(GLenum mode,GLint first,GLsizei count,GLsizei instancecount);

static inline void DrawArraysInstanced(GLenum mode,GLint first,GLsizei count,GLsizei instancecount)
{
	static PFNDRAWARRAYSINSTANCEDPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSINSTANCEDPROC_HPP>(_impl::_get_proc_address("glDrawArraysInstanced",3,1));
	 fn(mode,first,count,instancecount);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei instancecount);

static inline void DrawElementsInstanced(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei instancecount)
{
	static PFNDRAWELEMENTSINSTANCEDPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstanced",3,1));
	 fn(mode,count,type,indices,instancecount);
}

typedef void (*PFNTEXBUFFERPROC_HPP)(GLenum target,GLenum internalformat,GLuint buffer);

static inline void TexBuffer(GLenum target,GLenum internalformat,GLuint buffer)
{
	static PFNTEXBUFFERPROC_HPP fn=reinterpret_cast<PFNTEXBUFFERPROC_HPP>(_impl::_get_proc_address("glTexBuffer",3,1));
	 fn(target,internalformat,buffer);
}

typedef void (*PFNPRIMITIVERESTARTINDEXPROC_HPP)(GLuint index);

static inline void PrimitiveRestartIndex(GLuint index)
{
	static PFNPRIMITIVERESTARTINDEXPROC_HPP fn=reinterpret_cast<PFNPRIMITIVERESTARTINDEXPROC_HPP>(_impl::_get_proc_address("glPrimitiveRestartIndex",3,1));
	 fn(index);
}
#endif //(GLPROC_VERSION >= 31)
#if (GLPROC_VERSION >= 32)

#ifndef GL_VERSION_3_2

#define GL_VERSION_3_2
#ifndef GL_CONTEXT_CORE_PROFILE_BIT
#define GL_CONTEXT_CORE_PROFILE_BIT                                     0x00000001
#endif //GL_CONTEXT_CORE_PROFILE_BIT
#ifndef GL_SYNC_FLUSH_COMMANDS_BIT
#define GL_SYNC_FLUSH_COMMANDS_BIT                                      0x00000001
#endif //GL_SYNC_FLUSH_COMMANDS_BIT
#ifndef GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT                            0x00000002
#endif //GL_CONTEXT_COMPATIBILITY_PROFILE_BIT
#ifndef GL_LINES_ADJACENCY
#define GL_LINES_ADJACENCY                                              0x000A
#endif //GL_LINES_ADJACENCY
#ifndef GL_LINE_STRIP_ADJACENCY
#define GL_LINE_STRIP_ADJACENCY                                         0x000B
#endif //GL_LINE_STRIP_ADJACENCY
#ifndef GL_TRIANGLES_ADJACENCY
#define GL_TRIANGLES_ADJACENCY                                          0x000C
#endif //GL_TRIANGLES_ADJACENCY
#ifndef GL_TRIANGLE_STRIP_ADJACENCY
#define GL_TRIANGLE_STRIP_ADJACENCY                                     0x000D
#endif //GL_TRIANGLE_STRIP_ADJACENCY
#ifndef GL_PROGRAM_POINT_SIZE
#define GL_PROGRAM_POINT_SIZE                                           0x8642
#endif //GL_PROGRAM_POINT_SIZE
#ifndef GL_DEPTH_CLAMP
#define GL_DEPTH_CLAMP                                                  0x864F
#endif //GL_DEPTH_CLAMP
#ifndef GL_TEXTURE_CUBE_MAP_SEAMLESS
#define GL_TEXTURE_CUBE_MAP_SEAMLESS                                    0x884F
#endif //GL_TEXTURE_CUBE_MAP_SEAMLESS
#ifndef GL_GEOMETRY_VERTICES_OUT
#define GL_GEOMETRY_VERTICES_OUT                                        0x8916
#endif //GL_GEOMETRY_VERTICES_OUT
#ifndef GL_GEOMETRY_INPUT_TYPE
#define GL_GEOMETRY_INPUT_TYPE                                          0x8917
#endif //GL_GEOMETRY_INPUT_TYPE
#ifndef GL_GEOMETRY_OUTPUT_TYPE
#define GL_GEOMETRY_OUTPUT_TYPE                                         0x8918
#endif //GL_GEOMETRY_OUTPUT_TYPE
#ifndef GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS
#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS                             0x8C29
#endif //GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS
#ifndef GL_FRAMEBUFFER_ATTACHMENT_LAYERED
#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED                               0x8DA7
#endif //GL_FRAMEBUFFER_ATTACHMENT_LAYERED
#ifndef GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS                         0x8DA8
#endif //GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
#ifndef GL_GEOMETRY_SHADER
#define GL_GEOMETRY_SHADER                                              0x8DD9
#endif //GL_GEOMETRY_SHADER
#ifndef GL_MAX_GEOMETRY_UNIFORM_COMPONENTS
#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS                              0x8DDF
#endif //GL_MAX_GEOMETRY_UNIFORM_COMPONENTS
#ifndef GL_MAX_GEOMETRY_OUTPUT_VERTICES
#define GL_MAX_GEOMETRY_OUTPUT_VERTICES                                 0x8DE0
#endif //GL_MAX_GEOMETRY_OUTPUT_VERTICES
#ifndef GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS
#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS                         0x8DE1
#endif //GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS
#ifndef GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION
#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION                     0x8E4C
#endif //GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION
#ifndef GL_FIRST_VERTEX_CONVENTION
#define GL_FIRST_VERTEX_CONVENTION                                      0x8E4D
#endif //GL_FIRST_VERTEX_CONVENTION
#ifndef GL_LAST_VERTEX_CONVENTION
#define GL_LAST_VERTEX_CONVENTION                                       0x8E4E
#endif //GL_LAST_VERTEX_CONVENTION
#ifndef GL_PROVOKING_VERTEX
#define GL_PROVOKING_VERTEX                                             0x8E4F
#endif //GL_PROVOKING_VERTEX
#ifndef GL_SAMPLE_POSITION
#define GL_SAMPLE_POSITION                                              0x8E50
#endif //GL_SAMPLE_POSITION
#ifndef GL_SAMPLE_MASK
#define GL_SAMPLE_MASK                                                  0x8E51
#endif //GL_SAMPLE_MASK
#ifndef GL_SAMPLE_MASK_VALUE
#define GL_SAMPLE_MASK_VALUE                                            0x8E52
#endif //GL_SAMPLE_MASK_VALUE
#ifndef GL_MAX_SAMPLE_MASK_WORDS
#define GL_MAX_SAMPLE_MASK_WORDS                                        0x8E59
#endif //GL_MAX_SAMPLE_MASK_WORDS
#ifndef GL_TEXTURE_2D_MULTISAMPLE
#define GL_TEXTURE_2D_MULTISAMPLE                                       0x9100
#endif //GL_TEXTURE_2D_MULTISAMPLE
#ifndef GL_PROXY_TEXTURE_2D_MULTISAMPLE
#define GL_PROXY_TEXTURE_2D_MULTISAMPLE                                 0x9101
#endif //GL_PROXY_TEXTURE_2D_MULTISAMPLE
#ifndef GL_TEXTURE_2D_MULTISAMPLE_ARRAY
#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY                                 0x9102
#endif //GL_TEXTURE_2D_MULTISAMPLE_ARRAY
#ifndef GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY
#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY                           0x9103
#endif //GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY
#ifndef GL_TEXTURE_BINDING_2D_MULTISAMPLE
#define GL_TEXTURE_BINDING_2D_MULTISAMPLE                               0x9104
#endif //GL_TEXTURE_BINDING_2D_MULTISAMPLE
#ifndef GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY                         0x9105
#endif //GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
#ifndef GL_TEXTURE_SAMPLES
#define GL_TEXTURE_SAMPLES                                              0x9106
#endif //GL_TEXTURE_SAMPLES
#ifndef GL_TEXTURE_FIXED_SAMPLE_LOCATIONS
#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS                               0x9107
#endif //GL_TEXTURE_FIXED_SAMPLE_LOCATIONS
#ifndef GL_SAMPLER_2D_MULTISAMPLE
#define GL_SAMPLER_2D_MULTISAMPLE                                       0x9108
#endif //GL_SAMPLER_2D_MULTISAMPLE
#ifndef GL_INT_SAMPLER_2D_MULTISAMPLE
#define GL_INT_SAMPLER_2D_MULTISAMPLE                                   0x9109
#endif //GL_INT_SAMPLER_2D_MULTISAMPLE
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE
#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE                          0x910A
#endif //GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE
#ifndef GL_SAMPLER_2D_MULTISAMPLE_ARRAY
#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY                                 0x910B
#endif //GL_SAMPLER_2D_MULTISAMPLE_ARRAY
#ifndef GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY                             0x910C
#endif //GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY                    0x910D
#endif //GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
#ifndef GL_MAX_COLOR_TEXTURE_SAMPLES
#define GL_MAX_COLOR_TEXTURE_SAMPLES                                    0x910E
#endif //GL_MAX_COLOR_TEXTURE_SAMPLES
#ifndef GL_MAX_DEPTH_TEXTURE_SAMPLES
#define GL_MAX_DEPTH_TEXTURE_SAMPLES                                    0x910F
#endif //GL_MAX_DEPTH_TEXTURE_SAMPLES
#ifndef GL_MAX_INTEGER_SAMPLES
#define GL_MAX_INTEGER_SAMPLES                                          0x9110
#endif //GL_MAX_INTEGER_SAMPLES
#ifndef GL_MAX_SERVER_WAIT_TIMEOUT
#define GL_MAX_SERVER_WAIT_TIMEOUT                                      0x9111
#endif //GL_MAX_SERVER_WAIT_TIMEOUT
#ifndef GL_OBJECT_TYPE
#define GL_OBJECT_TYPE                                                  0x9112
#endif //GL_OBJECT_TYPE
#ifndef GL_SYNC_CONDITION
#define GL_SYNC_CONDITION                                               0x9113
#endif //GL_SYNC_CONDITION
#ifndef GL_SYNC_STATUS
#define GL_SYNC_STATUS                                                  0x9114
#endif //GL_SYNC_STATUS
#ifndef GL_SYNC_FLAGS
#define GL_SYNC_FLAGS                                                   0x9115
#endif //GL_SYNC_FLAGS
#ifndef GL_SYNC_FENCE
#define GL_SYNC_FENCE                                                   0x9116
#endif //GL_SYNC_FENCE
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE
#define GL_SYNC_GPU_COMMANDS_COMPLETE                                   0x9117
#endif //GL_SYNC_GPU_COMMANDS_COMPLETE
#ifndef GL_UNSIGNALED
#define GL_UNSIGNALED                                                   0x9118
#endif //GL_UNSIGNALED
#ifndef GL_SIGNALED
#define GL_SIGNALED                                                     0x9119
#endif //GL_SIGNALED
#ifndef GL_ALREADY_SIGNALED
#define GL_ALREADY_SIGNALED                                             0x911A
#endif //GL_ALREADY_SIGNALED
#ifndef GL_TIMEOUT_EXPIRED
#define GL_TIMEOUT_EXPIRED                                              0x911B
#endif //GL_TIMEOUT_EXPIRED
#ifndef GL_CONDITION_SATISFIED
#define GL_CONDITION_SATISFIED                                          0x911C
#endif //GL_CONDITION_SATISFIED
#ifndef GL_WAIT_FAILED
#define GL_WAIT_FAILED                                                  0x911D
#endif //GL_WAIT_FAILED
#ifndef GL_MAX_VERTEX_OUTPUT_COMPONENTS
#define GL_MAX_VERTEX_OUTPUT_COMPONENTS                                 0x9122
#endif //GL_MAX_VERTEX_OUTPUT_COMPONENTS
#ifndef GL_MAX_GEOMETRY_INPUT_COMPONENTS
#define GL_MAX_GEOMETRY_INPUT_COMPONENTS                                0x9123
#endif //GL_MAX_GEOMETRY_INPUT_COMPONENTS
#ifndef GL_MAX_GEOMETRY_OUTPUT_COMPONENTS
#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS                               0x9124
#endif //GL_MAX_GEOMETRY_OUTPUT_COMPONENTS
#ifndef GL_MAX_FRAGMENT_INPUT_COMPONENTS
#define GL_MAX_FRAGMENT_INPUT_COMPONENTS                                0x9125
#endif //GL_MAX_FRAGMENT_INPUT_COMPONENTS
#ifndef GL_CONTEXT_PROFILE_MASK
#define GL_CONTEXT_PROFILE_MASK                                         0x9126
#endif //GL_CONTEXT_PROFILE_MASK
#ifndef GL_TIMEOUT_IGNORED
#define GL_TIMEOUT_IGNORED                                              0xFFFFFFFFFFFFFFFF
#endif //GL_TIMEOUT_IGNORED

#endif //GL_VERSION_3_2


typedef void (*PFNGETINTEGER64I_VPROC_HPP)(GLenum target,GLuint index,GLint64 *data);

static inline void GetInteger64i_v(GLenum target,GLuint index,GLint64 *data)
{
	static PFNGETINTEGER64I_VPROC_HPP fn=reinterpret_cast<PFNGETINTEGER64I_VPROC_HPP>(_impl::_get_proc_address("glGetInteger64i_v",3,2));
	 fn(target,index,data);
}

typedef void (*PFNGETBUFFERPARAMETERI64VPROC_HPP)(GLenum target,GLenum pname,GLint64 *params);

static inline void GetBufferParameteri64v(GLenum target,GLenum pname,GLint64 *params)
{
	static PFNGETBUFFERPARAMETERI64VPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPARAMETERI64VPROC_HPP>(_impl::_get_proc_address("glGetBufferParameteri64v",3,2));
	 fn(target,pname,params);
}

typedef void (*PFNFRAMEBUFFERTEXTUREPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level);

static inline void FramebufferTexture(GLenum target,GLenum attachment,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTUREPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTUREPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture",3,2));
	 fn(target,attachment,texture,level);
}
#endif //(GLPROC_VERSION >= 32)
#if (GLPROC_VERSION >= 33)

#ifndef GL_VERSION_3_3

#define GL_VERSION_3_3
#ifndef GL_VERTEX_ATTRIB_ARRAY_DIVISOR
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR                                  0x88FE
#endif //GL_VERTEX_ATTRIB_ARRAY_DIVISOR

#endif //GL_VERSION_3_3


typedef void (*PFNVERTEXATTRIBDIVISORPROC_HPP)(GLuint index,GLuint divisor);

static inline void VertexAttribDivisor(GLuint index,GLuint divisor)
{
	static PFNVERTEXATTRIBDIVISORPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBDIVISORPROC_HPP>(_impl::_get_proc_address("glVertexAttribDivisor",3,3));
	 fn(index,divisor);
}
#endif //(GLPROC_VERSION >= 33)
#if (GLPROC_VERSION >= 40)

#ifndef GL_VERSION_4_0

#define GL_VERSION_4_0

#endif //GL_VERSION_4_0


typedef void (*PFNMINSAMPLESHADINGPROC_HPP)(GLfloat value);

static inline void MinSampleShading(GLfloat value)
{
	static PFNMINSAMPLESHADINGPROC_HPP fn=reinterpret_cast<PFNMINSAMPLESHADINGPROC_HPP>(_impl::_get_proc_address("glMinSampleShading",4,0));
	 fn(value);
}

typedef void (*PFNBLENDEQUATIONIPROC_HPP)(GLuint buf,GLenum mode);

static inline void BlendEquationi(GLuint buf,GLenum mode)
{
	static PFNBLENDEQUATIONIPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONIPROC_HPP>(_impl::_get_proc_address("glBlendEquationi",4,0));
	 fn(buf,mode);
}

typedef void (*PFNBLENDEQUATIONSEPARATEIPROC_HPP)(GLuint buf,GLenum modeRGB,GLenum modeAlpha);

static inline void BlendEquationSeparatei(GLuint buf,GLenum modeRGB,GLenum modeAlpha)
{
	static PFNBLENDEQUATIONSEPARATEIPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONSEPARATEIPROC_HPP>(_impl::_get_proc_address("glBlendEquationSeparatei",4,0));
	 fn(buf,modeRGB,modeAlpha);
}

typedef void (*PFNBLENDFUNCIPROC_HPP)(GLuint buf,GLenum src,GLenum dst);

static inline void BlendFunci(GLuint buf,GLenum src,GLenum dst)
{
	static PFNBLENDFUNCIPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCIPROC_HPP>(_impl::_get_proc_address("glBlendFunci",4,0));
	 fn(buf,src,dst);
}

typedef void (*PFNBLENDFUNCSEPARATEIPROC_HPP)(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);

static inline void BlendFuncSeparatei(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)
{
	static PFNBLENDFUNCSEPARATEIPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEIPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparatei",4,0));
	 fn(buf,srcRGB,dstRGB,srcAlpha,dstAlpha);
}
#endif //(GLPROC_VERSION >= 40)
#if (GLPROC_VERSION >= 43)

#ifndef GL_VERSION_4_3

#define GL_VERSION_4_3
#ifndef GL_CONTEXT_FLAG_DEBUG_BIT
#define GL_CONTEXT_FLAG_DEBUG_BIT                                       0x00000002
#endif //GL_CONTEXT_FLAG_DEBUG_BIT
#ifndef GL_NUM_SHADING_LANGUAGE_VERSIONS
#define GL_NUM_SHADING_LANGUAGE_VERSIONS                                0x82E9
#endif //GL_NUM_SHADING_LANGUAGE_VERSIONS
#ifndef GL_VERTEX_ATTRIB_ARRAY_LONG
#define GL_VERTEX_ATTRIB_ARRAY_LONG                                     0x874E
#endif //GL_VERTEX_ATTRIB_ARRAY_LONG

#endif //GL_VERSION_4_3

#endif //(GLPROC_VERSION >= 43)

#ifndef GL_

#define GL_
#ifndef GL_SGIX_list_priority
#define GL_SGIX_list_priority                                           1
#endif //GL_SGIX_list_priority
#ifndef GL_EXT_packed_pixels
#define GL_EXT_packed_pixels                                            1
#endif //GL_EXT_packed_pixels
#ifndef GL_SGIX_ycrcb
#define GL_SGIX_ycrcb                                                   1
#endif //GL_SGIX_ycrcb
#ifndef GL_SGIX_fog_offset
#define GL_SGIX_fog_offset                                              1
#endif //GL_SGIX_fog_offset
#ifndef GL_EXT_blend_minmax
#define GL_EXT_blend_minmax                                             1
#endif //GL_EXT_blend_minmax
#ifndef GL_SGIS_detail_texture
#define GL_SGIS_detail_texture                                          1
#endif //GL_SGIS_detail_texture
#ifndef GL_SGIX_reference_plane
#define GL_SGIX_reference_plane                                         1
#endif //GL_SGIX_reference_plane
#ifndef GL_SGIS_texture_border_clamp
#define GL_SGIS_texture_border_clamp                                    1
#endif //GL_SGIS_texture_border_clamp
#ifndef GL_SGIX_shadow
#define GL_SGIX_shadow                                                  1
#endif //GL_SGIX_shadow
#ifndef GL_SGIX_async_pixel
#define GL_SGIX_async_pixel                                             1
#endif //GL_SGIX_async_pixel
#ifndef GL_SGIX_ir_instrument1
#define GL_SGIX_ir_instrument1                                          1
#endif //GL_SGIX_ir_instrument1
#ifndef GL_EXT_rescale_normal
#define GL_EXT_rescale_normal                                           1
#endif //GL_EXT_rescale_normal
#ifndef GL_SGIX_subsample
#define GL_SGIX_subsample                                               1
#endif //GL_SGIX_subsample
#ifndef GL_SGI_color_table
#define GL_SGI_color_table                                              1
#endif //GL_SGI_color_table
#ifndef GL_SGIS_texture_lod
#define GL_SGIS_texture_lod                                             1
#endif //GL_SGIS_texture_lod
#ifndef GL_EXT_copy_texture
#define GL_EXT_copy_texture                                             1
#endif //GL_EXT_copy_texture
#ifndef GL_SGIS_point_parameters
#define GL_SGIS_point_parameters                                        1
#endif //GL_SGIS_point_parameters
#ifndef GL_SGI_texture_color_table
#define GL_SGI_texture_color_table                                      1
#endif //GL_SGI_texture_color_table
#ifndef GL_EXT_blend_color
#define GL_EXT_blend_color                                              1
#endif //GL_EXT_blend_color
#ifndef GL_SGIX_convolution_accuracy
#define GL_SGIX_convolution_accuracy                                    1
#endif //GL_SGIX_convolution_accuracy
#ifndef GL_EXT_vertex_array
#define GL_EXT_vertex_array                                             1
#endif //GL_EXT_vertex_array
#ifndef GL_EXT_subtexture
#define GL_EXT_subtexture                                               1
#endif //GL_EXT_subtexture
#ifndef GL_SGIX_blend_alpha_minmax
#define GL_SGIX_blend_alpha_minmax                                      1
#endif //GL_SGIX_blend_alpha_minmax
#ifndef GL_SGIX_calligraphic_fragment
#define GL_SGIX_calligraphic_fragment                                   1
#endif //GL_SGIX_calligraphic_fragment
#ifndef GL_SGIX_texture_lod_bias
#define GL_SGIX_texture_lod_bias                                        1
#endif //GL_SGIX_texture_lod_bias
#ifndef GL_SGIX_async
#define GL_SGIX_async                                                   1
#endif //GL_SGIX_async
#ifndef GL_SGIX_sprite
#define GL_SGIX_sprite                                                  1
#endif //GL_SGIX_sprite
#ifndef GL_SGIX_instruments
#define GL_SGIX_instruments                                             1
#endif //GL_SGIX_instruments
#ifndef GL_SGIS_texture4D
#define GL_SGIS_texture4D                                               1
#endif //GL_SGIS_texture4D
#ifndef GL_SGIX_interlace
#define GL_SGIX_interlace                                               1
#endif //GL_SGIX_interlace
#ifndef GL_SGIS_pixel_texture
#define GL_SGIS_pixel_texture                                           1
#endif //GL_SGIS_pixel_texture
#ifndef GL_SGIX_async_histogram
#define GL_SGIX_async_histogram                                         1
#endif //GL_SGIX_async_histogram
#ifndef GL_SGIX_texture_add_env
#define GL_SGIX_texture_add_env                                         1
#endif //GL_SGIX_texture_add_env
#ifndef GL_SGIX_clipmap
#define GL_SGIX_clipmap                                                 1
#endif //GL_SGIX_clipmap
#ifndef GL_SGIX_vertex_preclip
#define GL_SGIX_vertex_preclip                                          1
#endif //GL_SGIX_vertex_preclip
#ifndef GL_EXT_texture
#define GL_EXT_texture                                                  1
#endif //GL_EXT_texture
#ifndef GL_EXT_histogram
#define GL_EXT_histogram                                                1
#endif //GL_EXT_histogram
#ifndef GL_EXT_point_parameters
#define GL_EXT_point_parameters                                         1
#endif //GL_EXT_point_parameters
#ifndef GL_VERSION_1_4
#define GL_VERSION_1_4                                                  1
#endif //GL_VERSION_1_4
#ifndef GL_VERSION_1_5
#define GL_VERSION_1_5                                                  1
#endif //GL_VERSION_1_5
#ifndef GL_VERSION_1_2
#define GL_VERSION_1_2                                                  1
#endif //GL_VERSION_1_2
#ifndef GL_VERSION_1_3
#define GL_VERSION_1_3                                                  1
#endif //GL_VERSION_1_3
#ifndef GL_VERSION_1_1
#define GL_VERSION_1_1                                                  1
#endif //GL_VERSION_1_1
#ifndef GL_EXT_cmyka
#define GL_EXT_cmyka                                                    1
#endif //GL_EXT_cmyka
#ifndef GL_SGIX_polynomial_ffd
#define GL_SGIX_polynomial_ffd                                          1
#endif //GL_SGIX_polynomial_ffd
#ifndef GL_SGIX_texture_coordinate_clamp
#define GL_SGIX_texture_coordinate_clamp                                1
#endif //GL_SGIX_texture_coordinate_clamp
#ifndef GL_SGIX_resample
#define GL_SGIX_resample                                                1
#endif //GL_SGIX_resample
#ifndef GL_VERSION_3_0
#define GL_VERSION_3_0                                                  1
#endif //GL_VERSION_3_0
#ifndef GL_VERSION_3_1
#define GL_VERSION_3_1                                                  1
#endif //GL_VERSION_3_1
#ifndef GL_VERSION_3_2
#define GL_VERSION_3_2                                                  1
#endif //GL_VERSION_3_2
#ifndef GL_SGIX_shadow_ambient
#define GL_SGIX_shadow_ambient                                          1
#endif //GL_SGIX_shadow_ambient
#ifndef GL_SGIS_texture_select
#define GL_SGIS_texture_select                                          1
#endif //GL_SGIS_texture_select
#ifndef GL_SGIX_texture_scale_bias
#define GL_SGIX_texture_scale_bias                                      1
#endif //GL_SGIX_texture_scale_bias
#ifndef GL_VERSION_2_1
#define GL_VERSION_2_1                                                  1
#endif //GL_VERSION_2_1
#ifndef GL_VERSION_2_0
#define GL_VERSION_2_0                                                  1
#endif //GL_VERSION_2_0
#ifndef GL_SGIX_icc_texture
#define GL_SGIX_icc_texture                                             1
#endif //GL_SGIX_icc_texture
#ifndef GL_SGIX_impact_pixel_texture
#define GL_SGIX_impact_pixel_texture                                    1
#endif //GL_SGIX_impact_pixel_texture
#ifndef GL_SGIX_fragment_lighting
#define GL_SGIX_fragment_lighting                                       1
#endif //GL_SGIX_fragment_lighting
#ifndef GL_SGI_color_matrix
#define GL_SGI_color_matrix                                             1
#endif //GL_SGI_color_matrix
#ifndef GL_SGIS_multisample
#define GL_SGIS_multisample                                             1
#endif //GL_SGIS_multisample
#ifndef GL_EXT_polygon_offset
#define GL_EXT_polygon_offset                                           1
#endif //GL_EXT_polygon_offset
#ifndef GL_SGIS_point_line_texgen
#define GL_SGIS_point_line_texgen                                       1
#endif //GL_SGIS_point_line_texgen
#ifndef GL_SGIS_texture_filter4
#define GL_SGIS_texture_filter4                                         1
#endif //GL_SGIS_texture_filter4
#ifndef GL_SGIX_pixel_texture
#define GL_SGIX_pixel_texture                                           1
#endif //GL_SGIX_pixel_texture
#ifndef GL_SGIX_flush_raster
#define GL_SGIX_flush_raster                                            1
#endif //GL_SGIX_flush_raster
#ifndef GL_EXT_shared_texture_palette
#define GL_EXT_shared_texture_palette                                   1
#endif //GL_EXT_shared_texture_palette
#ifndef GL_SGIX_scalebias_hint
#define GL_SGIX_scalebias_hint                                          1
#endif //GL_SGIX_scalebias_hint
#ifndef GL_SGIS_generate_mipmap
#define GL_SGIS_generate_mipmap                                         1
#endif //GL_SGIS_generate_mipmap
#ifndef GL_SGIS_fog_function
#define GL_SGIS_fog_function                                            1
#endif //GL_SGIS_fog_function
#ifndef GL_SGIX_framezoom
#define GL_SGIX_framezoom                                               1
#endif //GL_SGIX_framezoom
#ifndef GL_EXT_texture3D
#define GL_EXT_texture3D                                                1
#endif //GL_EXT_texture3D
#ifndef GL_EXT_blend_subtract
#define GL_EXT_blend_subtract                                           1
#endif //GL_EXT_blend_subtract
#ifndef GL_SGIS_texture_edge_clamp
#define GL_SGIS_texture_edge_clamp                                      1
#endif //GL_SGIS_texture_edge_clamp
#ifndef GL_SGIS_sharpen_texture
#define GL_SGIS_sharpen_texture                                         1
#endif //GL_SGIS_sharpen_texture
#ifndef GL_EXT_convolution
#define GL_EXT_convolution                                              1
#endif //GL_EXT_convolution
#ifndef GL_EXT_blend_logic_op
#define GL_EXT_blend_logic_op                                           1
#endif //GL_EXT_blend_logic_op
#ifndef GL_SGIX_texture_multi_buffer
#define GL_SGIX_texture_multi_buffer                                    1
#endif //GL_SGIX_texture_multi_buffer
#ifndef GL_EXT_abgr
#define GL_EXT_abgr                                                     1
#endif //GL_EXT_abgr
#ifndef GL_EXT_texture_object
#define GL_EXT_texture_object                                           1
#endif //GL_EXT_texture_object
#ifndef GL_SGIX_tag_sample_buffer
#define GL_SGIX_tag_sample_buffer                                       1
#endif //GL_SGIX_tag_sample_buffer
#ifndef GL_ARB_imaging
#define GL_ARB_imaging                                                  1
#endif //GL_ARB_imaging
#ifndef GL_SGIX_pixel_tiles
#define GL_SGIX_pixel_tiles                                             1
#endif //GL_SGIX_pixel_tiles
#ifndef GL_SGIX_depth_texture
#define GL_SGIX_depth_texture                                           1
#endif //GL_SGIX_depth_texture

#endif //GL_

#ifndef GL_3DFX_multisample

#define GL_3DFX_multisample
#ifndef GL_MULTISAMPLE_BIT_3DFX
#define GL_MULTISAMPLE_BIT_3DFX                                         0x20000000
#endif //GL_MULTISAMPLE_BIT_3DFX
#ifndef GL_MULTISAMPLE_3DFX
#define GL_MULTISAMPLE_3DFX                                             0x86B2
#endif //GL_MULTISAMPLE_3DFX
#ifndef GL_SAMPLE_BUFFERS_3DFX
#define GL_SAMPLE_BUFFERS_3DFX                                          0x86B3
#endif //GL_SAMPLE_BUFFERS_3DFX
#ifndef GL_SAMPLES_3DFX
#define GL_SAMPLES_3DFX                                                 0x86B4
#endif //GL_SAMPLES_3DFX

#endif //GL_3DFX_multisample

#ifndef GL_3DFX_tbuffer

#define GL_3DFX_tbuffer

#endif //GL_3DFX_tbuffer


typedef void (*PFNTBUFFERMASK3DFXPROC_HPP)(GLuint mask);

static inline void TbufferMask3DFX(GLuint mask)
{
	static PFNTBUFFERMASK3DFXPROC_HPP fn=reinterpret_cast<PFNTBUFFERMASK3DFXPROC_HPP>(_impl::_get_proc_address("glTbufferMask3DFX","GL_3DFX_tbuffer"));
	 fn(mask);
}
#ifndef GL_3DFX_texture_compression_FXT1

#define GL_3DFX_texture_compression_FXT1
#ifndef GL_COMPRESSED_RGB_FXT1_3DFX
#define GL_COMPRESSED_RGB_FXT1_3DFX                                     0x86B0
#endif //GL_COMPRESSED_RGB_FXT1_3DFX
#ifndef GL_COMPRESSED_RGBA_FXT1_3DFX
#define GL_COMPRESSED_RGBA_FXT1_3DFX                                    0x86B1
#endif //GL_COMPRESSED_RGBA_FXT1_3DFX

#endif //GL_3DFX_texture_compression_FXT1

#ifndef GL_AMD_blend_minmax_factor

#define GL_AMD_blend_minmax_factor
#ifndef GL_FACTOR_MIN_AMD
#define GL_FACTOR_MIN_AMD                                               0x901C
#endif //GL_FACTOR_MIN_AMD
#ifndef GL_FACTOR_MAX_AMD
#define GL_FACTOR_MAX_AMD                                               0x901D
#endif //GL_FACTOR_MAX_AMD

#endif //GL_AMD_blend_minmax_factor

#ifndef GL_AMD_compressed_3DC_texture

#define GL_AMD_compressed_3DC_texture
#ifndef GL_3DC_X_AMD
#define GL_3DC_X_AMD                                                    0x87F9
#endif //GL_3DC_X_AMD
#ifndef GL_3DC_XY_AMD
#define GL_3DC_XY_AMD                                                   0x87FA
#endif //GL_3DC_XY_AMD

#endif //GL_AMD_compressed_3DC_texture

#ifndef GL_AMD_compressed_ATC_texture

#define GL_AMD_compressed_ATC_texture
#ifndef GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
#define GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD                              0x87EE
#endif //GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
#ifndef GL_ATC_RGB_AMD
#define GL_ATC_RGB_AMD                                                  0x8C92
#endif //GL_ATC_RGB_AMD
#ifndef GL_ATC_RGBA_EXPLICIT_ALPHA_AMD
#define GL_ATC_RGBA_EXPLICIT_ALPHA_AMD                                  0x8C93
#endif //GL_ATC_RGBA_EXPLICIT_ALPHA_AMD

#endif //GL_AMD_compressed_ATC_texture

#ifndef GL_AMD_debug_output

#define GL_AMD_debug_output
#ifndef GL_MAX_DEBUG_MESSAGE_LENGTH_AMD
#define GL_MAX_DEBUG_MESSAGE_LENGTH_AMD                                 0x9143
#endif //GL_MAX_DEBUG_MESSAGE_LENGTH_AMD
#ifndef GL_MAX_DEBUG_LOGGED_MESSAGES_AMD
#define GL_MAX_DEBUG_LOGGED_MESSAGES_AMD                                0x9144
#endif //GL_MAX_DEBUG_LOGGED_MESSAGES_AMD
#ifndef GL_DEBUG_LOGGED_MESSAGES_AMD
#define GL_DEBUG_LOGGED_MESSAGES_AMD                                    0x9145
#endif //GL_DEBUG_LOGGED_MESSAGES_AMD
#ifndef GL_DEBUG_SEVERITY_HIGH_AMD
#define GL_DEBUG_SEVERITY_HIGH_AMD                                      0x9146
#endif //GL_DEBUG_SEVERITY_HIGH_AMD
#ifndef GL_DEBUG_SEVERITY_MEDIUM_AMD
#define GL_DEBUG_SEVERITY_MEDIUM_AMD                                    0x9147
#endif //GL_DEBUG_SEVERITY_MEDIUM_AMD
#ifndef GL_DEBUG_SEVERITY_LOW_AMD
#define GL_DEBUG_SEVERITY_LOW_AMD                                       0x9148
#endif //GL_DEBUG_SEVERITY_LOW_AMD
#ifndef GL_DEBUG_CATEGORY_API_ERROR_AMD
#define GL_DEBUG_CATEGORY_API_ERROR_AMD                                 0x9149
#endif //GL_DEBUG_CATEGORY_API_ERROR_AMD
#ifndef GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD
#define GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD                             0x914A
#endif //GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD
#ifndef GL_DEBUG_CATEGORY_DEPRECATION_AMD
#define GL_DEBUG_CATEGORY_DEPRECATION_AMD                               0x914B
#endif //GL_DEBUG_CATEGORY_DEPRECATION_AMD
#ifndef GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD
#define GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD                        0x914C
#endif //GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD
#ifndef GL_DEBUG_CATEGORY_PERFORMANCE_AMD
#define GL_DEBUG_CATEGORY_PERFORMANCE_AMD                               0x914D
#endif //GL_DEBUG_CATEGORY_PERFORMANCE_AMD
#ifndef GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD
#define GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD                           0x914E
#endif //GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD
#ifndef GL_DEBUG_CATEGORY_APPLICATION_AMD
#define GL_DEBUG_CATEGORY_APPLICATION_AMD                               0x914F
#endif //GL_DEBUG_CATEGORY_APPLICATION_AMD
#ifndef GL_DEBUG_CATEGORY_OTHER_AMD
#define GL_DEBUG_CATEGORY_OTHER_AMD                                     0x9150
#endif //GL_DEBUG_CATEGORY_OTHER_AMD

#endif //GL_AMD_debug_output


typedef void (*PFNDEBUGMESSAGEENABLEAMDPROC_HPP)(GLenum category,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled);

static inline void DebugMessageEnableAMD(GLenum category,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled)
{
	static PFNDEBUGMESSAGEENABLEAMDPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGEENABLEAMDPROC_HPP>(_impl::_get_proc_address("glDebugMessageEnableAMD","GL_AMD_debug_output"));
	 fn(category,severity,count,ids,enabled);
}

typedef void (*PFNDEBUGMESSAGEINSERTAMDPROC_HPP)(GLenum category,GLenum severity,GLuint id,GLsizei length,const GLchar *buf);

static inline void DebugMessageInsertAMD(GLenum category,GLenum severity,GLuint id,GLsizei length,const GLchar *buf)
{
	static PFNDEBUGMESSAGEINSERTAMDPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGEINSERTAMDPROC_HPP>(_impl::_get_proc_address("glDebugMessageInsertAMD","GL_AMD_debug_output"));
	 fn(category,severity,id,length,buf);
}

typedef void (*PFNDEBUGMESSAGECALLBACKAMDPROC_HPP)(GLDEBUGPROCAMD callback,GLvoid *userParam);

static inline void DebugMessageCallbackAMD(GLDEBUGPROCAMD callback,GLvoid *userParam)
{
	static PFNDEBUGMESSAGECALLBACKAMDPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGECALLBACKAMDPROC_HPP>(_impl::_get_proc_address("glDebugMessageCallbackAMD","GL_AMD_debug_output"));
	 fn(callback,userParam);
}

typedef GLuint (*PFNGETDEBUGMESSAGELOGAMDPROC_HPP)(GLuint count,GLsizei bufsize,GLenum *categories,GLuint *severities,GLuint *ids,GLsizei *lengths,GLchar *message);

static inline GLuint GetDebugMessageLogAMD(GLuint count,GLsizei bufsize,GLenum *categories,GLuint *severities,GLuint *ids,GLsizei *lengths,GLchar *message)
{
	static PFNGETDEBUGMESSAGELOGAMDPROC_HPP fn=reinterpret_cast<PFNGETDEBUGMESSAGELOGAMDPROC_HPP>(_impl::_get_proc_address("glGetDebugMessageLogAMD","GL_AMD_debug_output"));
	return fn(count,bufsize,categories,severities,ids,lengths,message);
}
#ifndef GL_AMD_depth_clamp_separate

#define GL_AMD_depth_clamp_separate
#ifndef GL_DEPTH_CLAMP_NEAR_AMD
#define GL_DEPTH_CLAMP_NEAR_AMD                                         0x901E
#endif //GL_DEPTH_CLAMP_NEAR_AMD
#ifndef GL_DEPTH_CLAMP_FAR_AMD
#define GL_DEPTH_CLAMP_FAR_AMD                                          0x901F
#endif //GL_DEPTH_CLAMP_FAR_AMD

#endif //GL_AMD_depth_clamp_separate

#ifndef GL_AMD_draw_buffers_blend

#define GL_AMD_draw_buffers_blend

#endif //GL_AMD_draw_buffers_blend


typedef void (*PFNBLENDFUNCINDEXEDAMDPROC_HPP)(GLuint buf,GLenum src,GLenum dst);

static inline void BlendFuncIndexedAMD(GLuint buf,GLenum src,GLenum dst)
{
	static PFNBLENDFUNCINDEXEDAMDPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCINDEXEDAMDPROC_HPP>(_impl::_get_proc_address("glBlendFuncIndexedAMD","GL_AMD_draw_buffers_blend"));
	 fn(buf,src,dst);
}

typedef void (*PFNBLENDFUNCSEPARATEINDEXEDAMDPROC_HPP)(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);

static inline void BlendFuncSeparateIndexedAMD(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)
{
	static PFNBLENDFUNCSEPARATEINDEXEDAMDPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEINDEXEDAMDPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparateIndexedAMD","GL_AMD_draw_buffers_blend"));
	 fn(buf,srcRGB,dstRGB,srcAlpha,dstAlpha);
}

typedef void (*PFNBLENDEQUATIONINDEXEDAMDPROC_HPP)(GLuint buf,GLenum mode);

static inline void BlendEquationIndexedAMD(GLuint buf,GLenum mode)
{
	static PFNBLENDEQUATIONINDEXEDAMDPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONINDEXEDAMDPROC_HPP>(_impl::_get_proc_address("glBlendEquationIndexedAMD","GL_AMD_draw_buffers_blend"));
	 fn(buf,mode);
}

typedef void (*PFNBLENDEQUATIONSEPARATEINDEXEDAMDPROC_HPP)(GLuint buf,GLenum modeRGB,GLenum modeAlpha);

static inline void BlendEquationSeparateIndexedAMD(GLuint buf,GLenum modeRGB,GLenum modeAlpha)
{
	static PFNBLENDEQUATIONSEPARATEINDEXEDAMDPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONSEPARATEINDEXEDAMDPROC_HPP>(_impl::_get_proc_address("glBlendEquationSeparateIndexedAMD","GL_AMD_draw_buffers_blend"));
	 fn(buf,modeRGB,modeAlpha);
}
#ifndef GL_AMD_multi_draw_indirect

#define GL_AMD_multi_draw_indirect

#endif //GL_AMD_multi_draw_indirect


typedef void (*PFNMULTIDRAWARRAYSINDIRECTAMDPROC_HPP)(GLenum mode,const GLvoid *indirect,GLsizei primcount,GLsizei stride);

static inline void MultiDrawArraysIndirectAMD(GLenum mode,const GLvoid *indirect,GLsizei primcount,GLsizei stride)
{
	static PFNMULTIDRAWARRAYSINDIRECTAMDPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWARRAYSINDIRECTAMDPROC_HPP>(_impl::_get_proc_address("glMultiDrawArraysIndirectAMD","GL_AMD_multi_draw_indirect"));
	 fn(mode,indirect,primcount,stride);
}

typedef void (*PFNMULTIDRAWELEMENTSINDIRECTAMDPROC_HPP)(GLenum mode,GLenum type,const GLvoid *indirect,GLsizei primcount,GLsizei stride);

static inline void MultiDrawElementsIndirectAMD(GLenum mode,GLenum type,const GLvoid *indirect,GLsizei primcount,GLsizei stride)
{
	static PFNMULTIDRAWELEMENTSINDIRECTAMDPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTSINDIRECTAMDPROC_HPP>(_impl::_get_proc_address("glMultiDrawElementsIndirectAMD","GL_AMD_multi_draw_indirect"));
	 fn(mode,type,indirect,primcount,stride);
}
#ifndef GL_AMD_name_gen_delete

#define GL_AMD_name_gen_delete
#ifndef GL_DATA_BUFFER_AMD
#define GL_DATA_BUFFER_AMD                                              0x9151
#endif //GL_DATA_BUFFER_AMD
#ifndef GL_PERFORMANCE_MONITOR_AMD
#define GL_PERFORMANCE_MONITOR_AMD                                      0x9152
#endif //GL_PERFORMANCE_MONITOR_AMD
#ifndef GL_QUERY_OBJECT_AMD
#define GL_QUERY_OBJECT_AMD                                             0x9153
#endif //GL_QUERY_OBJECT_AMD
#ifndef GL_VERTEX_ARRAY_OBJECT_AMD
#define GL_VERTEX_ARRAY_OBJECT_AMD                                      0x9154
#endif //GL_VERTEX_ARRAY_OBJECT_AMD
#ifndef GL_SAMPLER_OBJECT_AMD
#define GL_SAMPLER_OBJECT_AMD                                           0x9155
#endif //GL_SAMPLER_OBJECT_AMD

#endif //GL_AMD_name_gen_delete


typedef void (*PFNGENNAMESAMDPROC_HPP)(GLenum identifier,GLuint num,GLuint *names);

static inline void GenNamesAMD(GLenum identifier,GLuint num,GLuint *names)
{
	static PFNGENNAMESAMDPROC_HPP fn=reinterpret_cast<PFNGENNAMESAMDPROC_HPP>(_impl::_get_proc_address("glGenNamesAMD","GL_AMD_name_gen_delete"));
	 fn(identifier,num,names);
}

typedef void (*PFNDELETENAMESAMDPROC_HPP)(GLenum identifier,GLuint num,const GLuint *names);

static inline void DeleteNamesAMD(GLenum identifier,GLuint num,const GLuint *names)
{
	static PFNDELETENAMESAMDPROC_HPP fn=reinterpret_cast<PFNDELETENAMESAMDPROC_HPP>(_impl::_get_proc_address("glDeleteNamesAMD","GL_AMD_name_gen_delete"));
	 fn(identifier,num,names);
}

typedef GLboolean (*PFNISNAMEAMDPROC_HPP)(GLenum identifier,GLuint name);

static inline GLboolean IsNameAMD(GLenum identifier,GLuint name)
{
	static PFNISNAMEAMDPROC_HPP fn=reinterpret_cast<PFNISNAMEAMDPROC_HPP>(_impl::_get_proc_address("glIsNameAMD","GL_AMD_name_gen_delete"));
	return fn(identifier,name);
}
#ifndef GL_AMD_performance_monitor

#define GL_AMD_performance_monitor
#ifndef GL_COUNTER_TYPE_AMD
#define GL_COUNTER_TYPE_AMD                                             0x8BC0
#endif //GL_COUNTER_TYPE_AMD
#ifndef GL_COUNTER_RANGE_AMD
#define GL_COUNTER_RANGE_AMD                                            0x8BC1
#endif //GL_COUNTER_RANGE_AMD
#ifndef GL_UNSIGNED_INT64_AMD
#define GL_UNSIGNED_INT64_AMD                                           0x8BC2
#endif //GL_UNSIGNED_INT64_AMD
#ifndef GL_PERCENTAGE_AMD
#define GL_PERCENTAGE_AMD                                               0x8BC3
#endif //GL_PERCENTAGE_AMD
#ifndef GL_PERFMON_RESULT_AVAILABLE_AMD
#define GL_PERFMON_RESULT_AVAILABLE_AMD                                 0x8BC4
#endif //GL_PERFMON_RESULT_AVAILABLE_AMD
#ifndef GL_PERFMON_RESULT_SIZE_AMD
#define GL_PERFMON_RESULT_SIZE_AMD                                      0x8BC5
#endif //GL_PERFMON_RESULT_SIZE_AMD
#ifndef GL_PERFMON_RESULT_AMD
#define GL_PERFMON_RESULT_AMD                                           0x8BC6
#endif //GL_PERFMON_RESULT_AMD

#endif //GL_AMD_performance_monitor


typedef void (*PFNGETPERFMONITORGROUPSAMDPROC_HPP)(GLint *numGroups,GLsizei groupsSize,GLuint *groups);

static inline void GetPerfMonitorGroupsAMD(GLint *numGroups,GLsizei groupsSize,GLuint *groups)
{
	static PFNGETPERFMONITORGROUPSAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORGROUPSAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorGroupsAMD","GL_AMD_performance_monitor"));
	 fn(numGroups,groupsSize,groups);
}

typedef void (*PFNGETPERFMONITORCOUNTERSAMDPROC_HPP)(GLuint group,GLint *numCounters,GLint *maxActiveCounters,GLsizei counterSize,GLuint *counters);

static inline void GetPerfMonitorCountersAMD(GLuint group,GLint *numCounters,GLint *maxActiveCounters,GLsizei counterSize,GLuint *counters)
{
	static PFNGETPERFMONITORCOUNTERSAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORCOUNTERSAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorCountersAMD","GL_AMD_performance_monitor"));
	 fn(group,numCounters,maxActiveCounters,counterSize,counters);
}

typedef void (*PFNGETPERFMONITORGROUPSTRINGAMDPROC_HPP)(GLuint group,GLsizei bufSize,GLsizei *length,GLchar *groupString);

static inline void GetPerfMonitorGroupStringAMD(GLuint group,GLsizei bufSize,GLsizei *length,GLchar *groupString)
{
	static PFNGETPERFMONITORGROUPSTRINGAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORGROUPSTRINGAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorGroupStringAMD","GL_AMD_performance_monitor"));
	 fn(group,bufSize,length,groupString);
}

typedef void (*PFNGETPERFMONITORCOUNTERSTRINGAMDPROC_HPP)(GLuint group,GLuint counter,GLsizei bufSize,GLsizei *length,GLchar *counterString);

static inline void GetPerfMonitorCounterStringAMD(GLuint group,GLuint counter,GLsizei bufSize,GLsizei *length,GLchar *counterString)
{
	static PFNGETPERFMONITORCOUNTERSTRINGAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORCOUNTERSTRINGAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorCounterStringAMD","GL_AMD_performance_monitor"));
	 fn(group,counter,bufSize,length,counterString);
}

typedef void (*PFNGETPERFMONITORCOUNTERINFOAMDPROC_HPP)(GLuint group,GLuint counter,GLenum pname,GLvoid *data);

static inline void GetPerfMonitorCounterInfoAMD(GLuint group,GLuint counter,GLenum pname,GLvoid *data)
{
	static PFNGETPERFMONITORCOUNTERINFOAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORCOUNTERINFOAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorCounterInfoAMD","GL_AMD_performance_monitor"));
	 fn(group,counter,pname,data);
}

typedef void (*PFNGENPERFMONITORSAMDPROC_HPP)(GLsizei n,GLuint *monitors);

static inline void GenPerfMonitorsAMD(GLsizei n,GLuint *monitors)
{
	static PFNGENPERFMONITORSAMDPROC_HPP fn=reinterpret_cast<PFNGENPERFMONITORSAMDPROC_HPP>(_impl::_get_proc_address("glGenPerfMonitorsAMD","GL_AMD_performance_monitor"));
	 fn(n,monitors);
}

typedef void (*PFNDELETEPERFMONITORSAMDPROC_HPP)(GLsizei n,GLuint *monitors);

static inline void DeletePerfMonitorsAMD(GLsizei n,GLuint *monitors)
{
	static PFNDELETEPERFMONITORSAMDPROC_HPP fn=reinterpret_cast<PFNDELETEPERFMONITORSAMDPROC_HPP>(_impl::_get_proc_address("glDeletePerfMonitorsAMD","GL_AMD_performance_monitor"));
	 fn(n,monitors);
}

typedef void (*PFNSELECTPERFMONITORCOUNTERSAMDPROC_HPP)(GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint *counterList);

static inline void SelectPerfMonitorCountersAMD(GLuint monitor,GLboolean enable,GLuint group,GLint numCounters,GLuint *counterList)
{
	static PFNSELECTPERFMONITORCOUNTERSAMDPROC_HPP fn=reinterpret_cast<PFNSELECTPERFMONITORCOUNTERSAMDPROC_HPP>(_impl::_get_proc_address("glSelectPerfMonitorCountersAMD","GL_AMD_performance_monitor"));
	 fn(monitor,enable,group,numCounters,counterList);
}

typedef void (*PFNBEGINPERFMONITORAMDPROC_HPP)(GLuint monitor);

static inline void BeginPerfMonitorAMD(GLuint monitor)
{
	static PFNBEGINPERFMONITORAMDPROC_HPP fn=reinterpret_cast<PFNBEGINPERFMONITORAMDPROC_HPP>(_impl::_get_proc_address("glBeginPerfMonitorAMD","GL_AMD_performance_monitor"));
	 fn(monitor);
}

typedef void (*PFNENDPERFMONITORAMDPROC_HPP)(GLuint monitor);

static inline void EndPerfMonitorAMD(GLuint monitor)
{
	static PFNENDPERFMONITORAMDPROC_HPP fn=reinterpret_cast<PFNENDPERFMONITORAMDPROC_HPP>(_impl::_get_proc_address("glEndPerfMonitorAMD","GL_AMD_performance_monitor"));
	 fn(monitor);
}

typedef void (*PFNGETPERFMONITORCOUNTERDATAAMDPROC_HPP)(GLuint monitor,GLenum pname,GLsizei dataSize,GLuint *data,GLint *bytesWritten);

static inline void GetPerfMonitorCounterDataAMD(GLuint monitor,GLenum pname,GLsizei dataSize,GLuint *data,GLint *bytesWritten)
{
	static PFNGETPERFMONITORCOUNTERDATAAMDPROC_HPP fn=reinterpret_cast<PFNGETPERFMONITORCOUNTERDATAAMDPROC_HPP>(_impl::_get_proc_address("glGetPerfMonitorCounterDataAMD","GL_AMD_performance_monitor"));
	 fn(monitor,pname,dataSize,data,bytesWritten);
}
#ifndef GL_AMD_pinned_memory

#define GL_AMD_pinned_memory
#ifndef GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD
#define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD                           0x9160
#endif //GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD

#endif //GL_AMD_pinned_memory

#ifndef GL_AMD_program_binary_Z400

#define GL_AMD_program_binary_Z400
#ifndef GL_Z400_BINARY_AMD
#define GL_Z400_BINARY_AMD                                              0x8740
#endif //GL_Z400_BINARY_AMD

#endif //GL_AMD_program_binary_Z400

#ifndef GL_AMD_query_buffer_object

#define GL_AMD_query_buffer_object
#ifndef GL_QUERY_BUFFER_AMD
#define GL_QUERY_BUFFER_AMD                                             0x9192
#endif //GL_QUERY_BUFFER_AMD
#ifndef GL_QUERY_BUFFER_BINDING_AMD
#define GL_QUERY_BUFFER_BINDING_AMD                                     0x9193
#endif //GL_QUERY_BUFFER_BINDING_AMD
#ifndef GL_QUERY_RESULT_NO_WAIT_AMD
#define GL_QUERY_RESULT_NO_WAIT_AMD                                     0x9194
#endif //GL_QUERY_RESULT_NO_WAIT_AMD

#endif //GL_AMD_query_buffer_object

#ifndef GL_AMD_sample_positions

#define GL_AMD_sample_positions
#ifndef GL_SUBSAMPLE_DISTANCE_AMD
#define GL_SUBSAMPLE_DISTANCE_AMD                                       0x883F
#endif //GL_SUBSAMPLE_DISTANCE_AMD

#endif //GL_AMD_sample_positions


typedef void (*PFNSETMULTISAMPLEFVAMDPROC_HPP)(GLenum pname,GLuint index,const GLfloat *val);

static inline void SetMultisamplefvAMD(GLenum pname,GLuint index,const GLfloat *val)
{
	static PFNSETMULTISAMPLEFVAMDPROC_HPP fn=reinterpret_cast<PFNSETMULTISAMPLEFVAMDPROC_HPP>(_impl::_get_proc_address("glSetMultisamplefvAMD","GL_AMD_sample_positions"));
	 fn(pname,index,val);
}
#ifndef GL_AMD_sparse_texture

#define GL_AMD_sparse_texture
#ifndef GL_TEXTURE_STORAGE_SPARSE_BIT_AMD
#define GL_TEXTURE_STORAGE_SPARSE_BIT_AMD                               0x00000001
#endif //GL_TEXTURE_STORAGE_SPARSE_BIT_AMD
#ifndef GL_VIRTUAL_PAGE_SIZE_X_AMD
#define GL_VIRTUAL_PAGE_SIZE_X_AMD                                      0x9195
#endif //GL_VIRTUAL_PAGE_SIZE_X_AMD
#ifndef GL_VIRTUAL_PAGE_SIZE_Y_AMD
#define GL_VIRTUAL_PAGE_SIZE_Y_AMD                                      0x9196
#endif //GL_VIRTUAL_PAGE_SIZE_Y_AMD
#ifndef GL_VIRTUAL_PAGE_SIZE_Z_AMD
#define GL_VIRTUAL_PAGE_SIZE_Z_AMD                                      0x9197
#endif //GL_VIRTUAL_PAGE_SIZE_Z_AMD
#ifndef GL_MAX_SPARSE_TEXTURE_SIZE_AMD
#define GL_MAX_SPARSE_TEXTURE_SIZE_AMD                                  0x9198
#endif //GL_MAX_SPARSE_TEXTURE_SIZE_AMD
#ifndef GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD
#define GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD                               0x9199
#endif //GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD
#ifndef GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS
#define GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS                              0x919A
#endif //GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS
#ifndef GL_MIN_SPARSE_LEVEL_AMD
#define GL_MIN_SPARSE_LEVEL_AMD                                         0x919B
#endif //GL_MIN_SPARSE_LEVEL_AMD
#ifndef GL_MIN_LOD_WARNING_AMD
#define GL_MIN_LOD_WARNING_AMD                                          0x919C
#endif //GL_MIN_LOD_WARNING_AMD

#endif //GL_AMD_sparse_texture


typedef void (*PFNTEXSTORAGESPARSEAMDPROC_HPP)(GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags);

static inline void TexStorageSparseAMD(GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags)
{
	static PFNTEXSTORAGESPARSEAMDPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGESPARSEAMDPROC_HPP>(_impl::_get_proc_address("glTexStorageSparseAMD","GL_AMD_sparse_texture"));
	 fn(target,internalFormat,width,height,depth,layers,flags);
}

typedef void (*PFNTEXTURESTORAGESPARSEAMDPROC_HPP)(GLuint texture,GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags);

static inline void TextureStorageSparseAMD(GLuint texture,GLenum target,GLenum internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLsizei layers,GLbitfield flags)
{
	static PFNTEXTURESTORAGESPARSEAMDPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGESPARSEAMDPROC_HPP>(_impl::_get_proc_address("glTextureStorageSparseAMD","GL_AMD_sparse_texture"));
	 fn(texture,target,internalFormat,width,height,depth,layers,flags);
}
#ifndef GL_AMD_stencil_operation_extended

#define GL_AMD_stencil_operation_extended
#ifndef GL_SET_AMD
#define GL_SET_AMD                                                      0x874A
#endif //GL_SET_AMD
#ifndef GL_REPLACE_VALUE_AMD
#define GL_REPLACE_VALUE_AMD                                            0x874B
#endif //GL_REPLACE_VALUE_AMD
#ifndef GL_STENCIL_OP_VALUE_AMD
#define GL_STENCIL_OP_VALUE_AMD                                         0x874C
#endif //GL_STENCIL_OP_VALUE_AMD
#ifndef GL_STENCIL_BACK_OP_VALUE_AMD
#define GL_STENCIL_BACK_OP_VALUE_AMD                                    0x874D
#endif //GL_STENCIL_BACK_OP_VALUE_AMD

#endif //GL_AMD_stencil_operation_extended


typedef void (*PFNSTENCILOPVALUEAMDPROC_HPP)(GLenum face,GLuint value);

static inline void StencilOpValueAMD(GLenum face,GLuint value)
{
	static PFNSTENCILOPVALUEAMDPROC_HPP fn=reinterpret_cast<PFNSTENCILOPVALUEAMDPROC_HPP>(_impl::_get_proc_address("glStencilOpValueAMD","GL_AMD_stencil_operation_extended"));
	 fn(face,value);
}
#ifndef GL_AMD_vertex_shader_tessellator

#define GL_AMD_vertex_shader_tessellator
#ifndef GL_SAMPLER_BUFFER_AMD
#define GL_SAMPLER_BUFFER_AMD                                           0x9001
#endif //GL_SAMPLER_BUFFER_AMD
#ifndef GL_INT_SAMPLER_BUFFER_AMD
#define GL_INT_SAMPLER_BUFFER_AMD                                       0x9002
#endif //GL_INT_SAMPLER_BUFFER_AMD
#ifndef GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD
#define GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD                              0x9003
#endif //GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD
#ifndef GL_TESSELLATION_MODE_AMD
#define GL_TESSELLATION_MODE_AMD                                        0x9004
#endif //GL_TESSELLATION_MODE_AMD
#ifndef GL_TESSELLATION_FACTOR_AMD
#define GL_TESSELLATION_FACTOR_AMD                                      0x9005
#endif //GL_TESSELLATION_FACTOR_AMD
#ifndef GL_DISCRETE_AMD
#define GL_DISCRETE_AMD                                                 0x9006
#endif //GL_DISCRETE_AMD
#ifndef GL_CONTINUOUS_AMD
#define GL_CONTINUOUS_AMD                                               0x9007
#endif //GL_CONTINUOUS_AMD

#endif //GL_AMD_vertex_shader_tessellator


typedef void (*PFNTESSELLATIONFACTORAMDPROC_HPP)(GLfloat factor);

static inline void TessellationFactorAMD(GLfloat factor)
{
	static PFNTESSELLATIONFACTORAMDPROC_HPP fn=reinterpret_cast<PFNTESSELLATIONFACTORAMDPROC_HPP>(_impl::_get_proc_address("glTessellationFactorAMD","GL_AMD_vertex_shader_tessellator"));
	 fn(factor);
}

typedef void (*PFNTESSELLATIONMODEAMDPROC_HPP)(GLenum mode);

static inline void TessellationModeAMD(GLenum mode)
{
	static PFNTESSELLATIONMODEAMDPROC_HPP fn=reinterpret_cast<PFNTESSELLATIONMODEAMDPROC_HPP>(_impl::_get_proc_address("glTessellationModeAMD","GL_AMD_vertex_shader_tessellator"));
	 fn(mode);
}
#ifndef GL_ANGLE_framebuffer_blit

#define GL_ANGLE_framebuffer_blit
#ifndef GL_FRAMEBUFFER_BINDING_ANGLE
#define GL_FRAMEBUFFER_BINDING_ANGLE                                    0x8CA6
#endif //GL_FRAMEBUFFER_BINDING_ANGLE
#ifndef GL_RENDERBUFFER_BINDING_ANGLE
#define GL_RENDERBUFFER_BINDING_ANGLE                                   0x8CA7
#endif //GL_RENDERBUFFER_BINDING_ANGLE
#ifndef GL_READ_FRAMEBUFFER_ANGLE
#define GL_READ_FRAMEBUFFER_ANGLE                                       0x8CA8
#endif //GL_READ_FRAMEBUFFER_ANGLE
#ifndef GL_DRAW_FRAMEBUFFER_ANGLE
#define GL_DRAW_FRAMEBUFFER_ANGLE                                       0x8CA9
#endif //GL_DRAW_FRAMEBUFFER_ANGLE

#endif //GL_ANGLE_framebuffer_blit

#ifndef GL_ANGLE_framebuffer_multisample

#define GL_ANGLE_framebuffer_multisample
#ifndef GL_RENDERBUFFER_SAMPLES_ANGLE
#define GL_RENDERBUFFER_SAMPLES_ANGLE                                   0x8CAB
#endif //GL_RENDERBUFFER_SAMPLES_ANGLE
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE                     0x8D56
#endif //GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE
#ifndef GL_MAX_SAMPLES_ANGLE
#define GL_MAX_SAMPLES_ANGLE                                            0x8D57
#endif //GL_MAX_SAMPLES_ANGLE

#endif //GL_ANGLE_framebuffer_multisample

#ifndef GL_ANGLE_instanced_arrays

#define GL_ANGLE_instanced_arrays
#ifndef GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE                            0x88FE
#endif //GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE

#endif //GL_ANGLE_instanced_arrays

#ifndef GL_ANGLE_pack_reverse_row_order

#define GL_ANGLE_pack_reverse_row_order
#ifndef GL_PACK_REVERSE_ROW_ORDER_ANGLE
#define GL_PACK_REVERSE_ROW_ORDER_ANGLE                                 0x93A4
#endif //GL_PACK_REVERSE_ROW_ORDER_ANGLE

#endif //GL_ANGLE_pack_reverse_row_order

#ifndef GL_ANGLE_texture_compression_dxt3

#define GL_ANGLE_texture_compression_dxt3
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE
#define GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE                              0x83F2
#endif //GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE

#endif //GL_ANGLE_texture_compression_dxt3

#ifndef GL_ANGLE_texture_compression_dxt5

#define GL_ANGLE_texture_compression_dxt5
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE
#define GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE                              0x83F3
#endif //GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE

#endif //GL_ANGLE_texture_compression_dxt5

#ifndef GL_ANGLE_texture_usage

#define GL_ANGLE_texture_usage
#ifndef GL_NONE
#define GL_NONE                                                         0
#endif //GL_NONE
#ifndef GL_TEXTURE_USAGE_ANGLE
#define GL_TEXTURE_USAGE_ANGLE                                          0x93A2
#endif //GL_TEXTURE_USAGE_ANGLE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_ANGLE
#define GL_FRAMEBUFFER_ATTACHMENT_ANGLE                                 0x93A3
#endif //GL_FRAMEBUFFER_ATTACHMENT_ANGLE

#endif //GL_ANGLE_texture_usage

#ifndef GL_ANGLE_translated_shader_source

#define GL_ANGLE_translated_shader_source
#ifndef GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE
#define GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE                        0x93A0
#endif //GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE

#endif //GL_ANGLE_translated_shader_source

#ifndef GL_APPLE_aux_depth_stencil

#define GL_APPLE_aux_depth_stencil
#ifndef GL_AUX_DEPTH_STENCIL_APPLE
#define GL_AUX_DEPTH_STENCIL_APPLE                                      0x8A14
#endif //GL_AUX_DEPTH_STENCIL_APPLE

#endif //GL_APPLE_aux_depth_stencil

#ifndef GL_APPLE_client_storage

#define GL_APPLE_client_storage
#ifndef GL_UNPACK_CLIENT_STORAGE_APPLE
#define GL_UNPACK_CLIENT_STORAGE_APPLE                                  0x85B2
#endif //GL_UNPACK_CLIENT_STORAGE_APPLE

#endif //GL_APPLE_client_storage

#ifndef GL_APPLE_element_array

#define GL_APPLE_element_array
#ifndef GL_ELEMENT_ARRAY_APPLE
#define GL_ELEMENT_ARRAY_APPLE                                          0x8A0C
#endif //GL_ELEMENT_ARRAY_APPLE
#ifndef GL_ELEMENT_ARRAY_TYPE_APPLE
#define GL_ELEMENT_ARRAY_TYPE_APPLE                                     0x8A0D
#endif //GL_ELEMENT_ARRAY_TYPE_APPLE
#ifndef GL_ELEMENT_ARRAY_POINTER_APPLE
#define GL_ELEMENT_ARRAY_POINTER_APPLE                                  0x8A0E
#endif //GL_ELEMENT_ARRAY_POINTER_APPLE

#endif //GL_APPLE_element_array


typedef void (*PFNELEMENTPOINTERAPPLEPROC_HPP)(GLenum type,const GLvoid *pointer);

static inline void ElementPointerAPPLE(GLenum type,const GLvoid *pointer)
{
	static PFNELEMENTPOINTERAPPLEPROC_HPP fn=reinterpret_cast<PFNELEMENTPOINTERAPPLEPROC_HPP>(_impl::_get_proc_address("glElementPointerAPPLE","GL_APPLE_element_array"));
	 fn(type,pointer);
}

typedef void (*PFNDRAWELEMENTARRAYAPPLEPROC_HPP)(GLenum mode,GLint first,GLsizei count);

static inline void DrawElementArrayAPPLE(GLenum mode,GLint first,GLsizei count)
{
	static PFNDRAWELEMENTARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glDrawElementArrayAPPLE","GL_APPLE_element_array"));
	 fn(mode,first,count);
}

typedef void (*PFNDRAWRANGEELEMENTARRAYAPPLEPROC_HPP)(GLenum mode,GLuint start,GLuint end,GLint first,GLsizei count);

static inline void DrawRangeElementArrayAPPLE(GLenum mode,GLuint start,GLuint end,GLint first,GLsizei count)
{
	static PFNDRAWRANGEELEMENTARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNDRAWRANGEELEMENTARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glDrawRangeElementArrayAPPLE","GL_APPLE_element_array"));
	 fn(mode,start,end,first,count);
}

typedef void (*PFNMULTIDRAWELEMENTARRAYAPPLEPROC_HPP)(GLenum mode,const GLint *first,const GLsizei *count,GLsizei primcount);

static inline void MultiDrawElementArrayAPPLE(GLenum mode,const GLint *first,const GLsizei *count,GLsizei primcount)
{
	static PFNMULTIDRAWELEMENTARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glMultiDrawElementArrayAPPLE","GL_APPLE_element_array"));
	 fn(mode,first,count,primcount);
}

typedef void (*PFNMULTIDRAWRANGEELEMENTARRAYAPPLEPROC_HPP)(GLenum mode,GLuint start,GLuint end,const GLint *first,const GLsizei *count,GLsizei primcount);

static inline void MultiDrawRangeElementArrayAPPLE(GLenum mode,GLuint start,GLuint end,const GLint *first,const GLsizei *count,GLsizei primcount)
{
	static PFNMULTIDRAWRANGEELEMENTARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWRANGEELEMENTARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glMultiDrawRangeElementArrayAPPLE","GL_APPLE_element_array"));
	 fn(mode,start,end,first,count,primcount);
}
#ifndef GL_APPLE_fence

#define GL_APPLE_fence
#ifndef GL_DRAW_PIXELS_APPLE
#define GL_DRAW_PIXELS_APPLE                                            0x8A0A
#endif //GL_DRAW_PIXELS_APPLE
#ifndef GL_FENCE_APPLE
#define GL_FENCE_APPLE                                                  0x8A0B
#endif //GL_FENCE_APPLE

#endif //GL_APPLE_fence


typedef void (*PFNGENFENCESAPPLEPROC_HPP)(GLsizei n,GLuint *fences);

static inline void GenFencesAPPLE(GLsizei n,GLuint *fences)
{
	static PFNGENFENCESAPPLEPROC_HPP fn=reinterpret_cast<PFNGENFENCESAPPLEPROC_HPP>(_impl::_get_proc_address("glGenFencesAPPLE","GL_APPLE_fence"));
	 fn(n,fences);
}

typedef void (*PFNDELETEFENCESAPPLEPROC_HPP)(GLsizei n,const GLuint *fences);

static inline void DeleteFencesAPPLE(GLsizei n,const GLuint *fences)
{
	static PFNDELETEFENCESAPPLEPROC_HPP fn=reinterpret_cast<PFNDELETEFENCESAPPLEPROC_HPP>(_impl::_get_proc_address("glDeleteFencesAPPLE","GL_APPLE_fence"));
	 fn(n,fences);
}

typedef void (*PFNSETFENCEAPPLEPROC_HPP)(GLuint fence);

static inline void SetFenceAPPLE(GLuint fence)
{
	static PFNSETFENCEAPPLEPROC_HPP fn=reinterpret_cast<PFNSETFENCEAPPLEPROC_HPP>(_impl::_get_proc_address("glSetFenceAPPLE","GL_APPLE_fence"));
	 fn(fence);
}

typedef GLboolean (*PFNISFENCEAPPLEPROC_HPP)(GLuint fence);

static inline GLboolean IsFenceAPPLE(GLuint fence)
{
	static PFNISFENCEAPPLEPROC_HPP fn=reinterpret_cast<PFNISFENCEAPPLEPROC_HPP>(_impl::_get_proc_address("glIsFenceAPPLE","GL_APPLE_fence"));
	return fn(fence);
}

typedef GLboolean (*PFNTESTFENCEAPPLEPROC_HPP)(GLuint fence);

static inline GLboolean TestFenceAPPLE(GLuint fence)
{
	static PFNTESTFENCEAPPLEPROC_HPP fn=reinterpret_cast<PFNTESTFENCEAPPLEPROC_HPP>(_impl::_get_proc_address("glTestFenceAPPLE","GL_APPLE_fence"));
	return fn(fence);
}

typedef void (*PFNFINISHFENCEAPPLEPROC_HPP)(GLuint fence);

static inline void FinishFenceAPPLE(GLuint fence)
{
	static PFNFINISHFENCEAPPLEPROC_HPP fn=reinterpret_cast<PFNFINISHFENCEAPPLEPROC_HPP>(_impl::_get_proc_address("glFinishFenceAPPLE","GL_APPLE_fence"));
	 fn(fence);
}

typedef GLboolean (*PFNTESTOBJECTAPPLEPROC_HPP)(GLenum object,GLuint name);

static inline GLboolean TestObjectAPPLE(GLenum object,GLuint name)
{
	static PFNTESTOBJECTAPPLEPROC_HPP fn=reinterpret_cast<PFNTESTOBJECTAPPLEPROC_HPP>(_impl::_get_proc_address("glTestObjectAPPLE","GL_APPLE_fence"));
	return fn(object,name);
}

typedef void (*PFNFINISHOBJECTAPPLEPROC_HPP)(GLenum object,GLint name);

static inline void FinishObjectAPPLE(GLenum object,GLint name)
{
	static PFNFINISHOBJECTAPPLEPROC_HPP fn=reinterpret_cast<PFNFINISHOBJECTAPPLEPROC_HPP>(_impl::_get_proc_address("glFinishObjectAPPLE","GL_APPLE_fence"));
	 fn(object,name);
}
#ifndef GL_APPLE_float_pixels

#define GL_APPLE_float_pixels
#ifndef GL_HALF_APPLE
#define GL_HALF_APPLE                                                   0x140B
#endif //GL_HALF_APPLE
#ifndef GL_RGBA_FLOAT32_APPLE
#define GL_RGBA_FLOAT32_APPLE                                           0x8814
#endif //GL_RGBA_FLOAT32_APPLE
#ifndef GL_RGB_FLOAT32_APPLE
#define GL_RGB_FLOAT32_APPLE                                            0x8815
#endif //GL_RGB_FLOAT32_APPLE
#ifndef GL_ALPHA_FLOAT32_APPLE
#define GL_ALPHA_FLOAT32_APPLE                                          0x8816
#endif //GL_ALPHA_FLOAT32_APPLE
#ifndef GL_INTENSITY_FLOAT32_APPLE
#define GL_INTENSITY_FLOAT32_APPLE                                      0x8817
#endif //GL_INTENSITY_FLOAT32_APPLE
#ifndef GL_LUMINANCE_FLOAT32_APPLE
#define GL_LUMINANCE_FLOAT32_APPLE                                      0x8818
#endif //GL_LUMINANCE_FLOAT32_APPLE
#ifndef GL_LUMINANCE_ALPHA_FLOAT32_APPLE
#define GL_LUMINANCE_ALPHA_FLOAT32_APPLE                                0x8819
#endif //GL_LUMINANCE_ALPHA_FLOAT32_APPLE
#ifndef GL_RGBA_FLOAT16_APPLE
#define GL_RGBA_FLOAT16_APPLE                                           0x881A
#endif //GL_RGBA_FLOAT16_APPLE
#ifndef GL_RGB_FLOAT16_APPLE
#define GL_RGB_FLOAT16_APPLE                                            0x881B
#endif //GL_RGB_FLOAT16_APPLE
#ifndef GL_ALPHA_FLOAT16_APPLE
#define GL_ALPHA_FLOAT16_APPLE                                          0x881C
#endif //GL_ALPHA_FLOAT16_APPLE
#ifndef GL_INTENSITY_FLOAT16_APPLE
#define GL_INTENSITY_FLOAT16_APPLE                                      0x881D
#endif //GL_INTENSITY_FLOAT16_APPLE
#ifndef GL_LUMINANCE_FLOAT16_APPLE
#define GL_LUMINANCE_FLOAT16_APPLE                                      0x881E
#endif //GL_LUMINANCE_FLOAT16_APPLE
#ifndef GL_LUMINANCE_ALPHA_FLOAT16_APPLE
#define GL_LUMINANCE_ALPHA_FLOAT16_APPLE                                0x881F
#endif //GL_LUMINANCE_ALPHA_FLOAT16_APPLE
#ifndef GL_COLOR_FLOAT_APPLE
#define GL_COLOR_FLOAT_APPLE                                            0x8A0F
#endif //GL_COLOR_FLOAT_APPLE

#endif //GL_APPLE_float_pixels

#ifndef GL_APPLE_flush_buffer_range

#define GL_APPLE_flush_buffer_range
#ifndef GL_BUFFER_SERIALIZED_MODIFY_APPLE
#define GL_BUFFER_SERIALIZED_MODIFY_APPLE                               0x8A12
#endif //GL_BUFFER_SERIALIZED_MODIFY_APPLE
#ifndef GL_BUFFER_FLUSHING_UNMAP_APPLE
#define GL_BUFFER_FLUSHING_UNMAP_APPLE                                  0x8A13
#endif //GL_BUFFER_FLUSHING_UNMAP_APPLE

#endif //GL_APPLE_flush_buffer_range


typedef void (*PFNBUFFERPARAMETERIAPPLEPROC_HPP)(GLenum target,GLenum pname,GLint param);

static inline void BufferParameteriAPPLE(GLenum target,GLenum pname,GLint param)
{
	static PFNBUFFERPARAMETERIAPPLEPROC_HPP fn=reinterpret_cast<PFNBUFFERPARAMETERIAPPLEPROC_HPP>(_impl::_get_proc_address("glBufferParameteriAPPLE","GL_APPLE_flush_buffer_range"));
	 fn(target,pname,param);
}

typedef void (*PFNFLUSHMAPPEDBUFFERRANGEAPPLEPROC_HPP)(GLenum target,GLintptr offset,GLsizeiptr size);

static inline void FlushMappedBufferRangeAPPLE(GLenum target,GLintptr offset,GLsizeiptr size)
{
	static PFNFLUSHMAPPEDBUFFERRANGEAPPLEPROC_HPP fn=reinterpret_cast<PFNFLUSHMAPPEDBUFFERRANGEAPPLEPROC_HPP>(_impl::_get_proc_address("glFlushMappedBufferRangeAPPLE","GL_APPLE_flush_buffer_range"));
	 fn(target,offset,size);
}
#ifndef GL_APPLE_object_purgeable

#define GL_APPLE_object_purgeable
#ifndef GL_BUFFER_OBJECT_APPLE
#define GL_BUFFER_OBJECT_APPLE                                          0x85B3
#endif //GL_BUFFER_OBJECT_APPLE
#ifndef GL_RELEASED_APPLE
#define GL_RELEASED_APPLE                                               0x8A19
#endif //GL_RELEASED_APPLE
#ifndef GL_VOLATILE_APPLE
#define GL_VOLATILE_APPLE                                               0x8A1A
#endif //GL_VOLATILE_APPLE
#ifndef GL_RETAINED_APPLE
#define GL_RETAINED_APPLE                                               0x8A1B
#endif //GL_RETAINED_APPLE
#ifndef GL_UNDEFINED_APPLE
#define GL_UNDEFINED_APPLE                                              0x8A1C
#endif //GL_UNDEFINED_APPLE
#ifndef GL_PURGEABLE_APPLE
#define GL_PURGEABLE_APPLE                                              0x8A1D
#endif //GL_PURGEABLE_APPLE

#endif //GL_APPLE_object_purgeable


typedef GLenum (*PFNOBJECTPURGEABLEAPPLEPROC_HPP)(GLenum objectType,GLuint name,GLenum option);

static inline GLenum ObjectPurgeableAPPLE(GLenum objectType,GLuint name,GLenum option)
{
	static PFNOBJECTPURGEABLEAPPLEPROC_HPP fn=reinterpret_cast<PFNOBJECTPURGEABLEAPPLEPROC_HPP>(_impl::_get_proc_address("glObjectPurgeableAPPLE","GL_APPLE_object_purgeable"));
	return fn(objectType,name,option);
}

typedef GLenum (*PFNOBJECTUNPURGEABLEAPPLEPROC_HPP)(GLenum objectType,GLuint name,GLenum option);

static inline GLenum ObjectUnpurgeableAPPLE(GLenum objectType,GLuint name,GLenum option)
{
	static PFNOBJECTUNPURGEABLEAPPLEPROC_HPP fn=reinterpret_cast<PFNOBJECTUNPURGEABLEAPPLEPROC_HPP>(_impl::_get_proc_address("glObjectUnpurgeableAPPLE","GL_APPLE_object_purgeable"));
	return fn(objectType,name,option);
}

typedef void (*PFNGETOBJECTPARAMETERIVAPPLEPROC_HPP)(GLenum objectType,GLuint name,GLenum pname,GLint *params);

static inline void GetObjectParameterivAPPLE(GLenum objectType,GLuint name,GLenum pname,GLint *params)
{
	static PFNGETOBJECTPARAMETERIVAPPLEPROC_HPP fn=reinterpret_cast<PFNGETOBJECTPARAMETERIVAPPLEPROC_HPP>(_impl::_get_proc_address("glGetObjectParameterivAPPLE","GL_APPLE_object_purgeable"));
	 fn(objectType,name,pname,params);
}
#ifndef GL_APPLE_rgb_422

#define GL_APPLE_rgb_422
#ifndef GL_UNSIGNED_SHORT_8_8_APPLE
#define GL_UNSIGNED_SHORT_8_8_APPLE                                     0x85BA
#endif //GL_UNSIGNED_SHORT_8_8_APPLE
#ifndef GL_UNSIGNED_SHORT_8_8_REV_APPLE
#define GL_UNSIGNED_SHORT_8_8_REV_APPLE                                 0x85BB
#endif //GL_UNSIGNED_SHORT_8_8_REV_APPLE
#ifndef GL_RGB_422_APPLE
#define GL_RGB_422_APPLE                                                0x8A1F
#endif //GL_RGB_422_APPLE

#endif //GL_APPLE_rgb_422

#ifndef GL_APPLE_row_bytes

#define GL_APPLE_row_bytes
#ifndef GL_PACK_ROW_BYTES_APPLE
#define GL_PACK_ROW_BYTES_APPLE                                         0x8A15
#endif //GL_PACK_ROW_BYTES_APPLE
#ifndef GL_UNPACK_ROW_BYTES_APPLE
#define GL_UNPACK_ROW_BYTES_APPLE                                       0x8A16
#endif //GL_UNPACK_ROW_BYTES_APPLE

#endif //GL_APPLE_row_bytes

#ifndef GL_APPLE_specular_vector

#define GL_APPLE_specular_vector
#ifndef GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE
#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE                            0x85B0
#endif //GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE

#endif //GL_APPLE_specular_vector

#ifndef GL_APPLE_sync

#define GL_APPLE_sync
#ifndef GL_SYNC_FLUSH_COMMANDS_BIT_APPLE
#define GL_SYNC_FLUSH_COMMANDS_BIT_APPLE                                0x00000001
#endif //GL_SYNC_FLUSH_COMMANDS_BIT_APPLE
#ifndef GL_SYNC_OBJECT_APPLE
#define GL_SYNC_OBJECT_APPLE                                            0x8A53
#endif //GL_SYNC_OBJECT_APPLE
#ifndef GL_MAX_SERVER_WAIT_TIMEOUT_APPLE
#define GL_MAX_SERVER_WAIT_TIMEOUT_APPLE                                0x9111
#endif //GL_MAX_SERVER_WAIT_TIMEOUT_APPLE
#ifndef GL_OBJECT_TYPE_APPLE
#define GL_OBJECT_TYPE_APPLE                                            0x9112
#endif //GL_OBJECT_TYPE_APPLE
#ifndef GL_SYNC_CONDITION_APPLE
#define GL_SYNC_CONDITION_APPLE                                         0x9113
#endif //GL_SYNC_CONDITION_APPLE
#ifndef GL_SYNC_STATUS_APPLE
#define GL_SYNC_STATUS_APPLE                                            0x9114
#endif //GL_SYNC_STATUS_APPLE
#ifndef GL_SYNC_FLAGS_APPLE
#define GL_SYNC_FLAGS_APPLE                                             0x9115
#endif //GL_SYNC_FLAGS_APPLE
#ifndef GL_SYNC_FENCE_APPLE
#define GL_SYNC_FENCE_APPLE                                             0x9116
#endif //GL_SYNC_FENCE_APPLE
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE
#define GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE                             0x9117
#endif //GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE
#ifndef GL_UNSIGNALED_APPLE
#define GL_UNSIGNALED_APPLE                                             0x9118
#endif //GL_UNSIGNALED_APPLE
#ifndef GL_SIGNALED_APPLE
#define GL_SIGNALED_APPLE                                               0x9119
#endif //GL_SIGNALED_APPLE
#ifndef GL_ALREADY_SIGNALED_APPLE
#define GL_ALREADY_SIGNALED_APPLE                                       0x911A
#endif //GL_ALREADY_SIGNALED_APPLE
#ifndef GL_TIMEOUT_EXPIRED_APPLE
#define GL_TIMEOUT_EXPIRED_APPLE                                        0x911B
#endif //GL_TIMEOUT_EXPIRED_APPLE
#ifndef GL_CONDITION_SATISFIED_APPLE
#define GL_CONDITION_SATISFIED_APPLE                                    0x911C
#endif //GL_CONDITION_SATISFIED_APPLE
#ifndef GL_WAIT_FAILED_APPLE
#define GL_WAIT_FAILED_APPLE                                            0x911D
#endif //GL_WAIT_FAILED_APPLE
#ifndef GL_TIMEOUT_IGNORED_APPLE
#define GL_TIMEOUT_IGNORED_APPLE                                        0xFFFFFFFFFFFFFFFF
#endif //GL_TIMEOUT_IGNORED_APPLE

#endif //GL_APPLE_sync

#ifndef GL_APPLE_texture_range

#define GL_APPLE_texture_range
#ifndef GL_TEXTURE_RANGE_LENGTH_APPLE
#define GL_TEXTURE_RANGE_LENGTH_APPLE                                   0x85B7
#endif //GL_TEXTURE_RANGE_LENGTH_APPLE
#ifndef GL_TEXTURE_RANGE_POINTER_APPLE
#define GL_TEXTURE_RANGE_POINTER_APPLE                                  0x85B8
#endif //GL_TEXTURE_RANGE_POINTER_APPLE
#ifndef GL_TEXTURE_STORAGE_HINT_APPLE
#define GL_TEXTURE_STORAGE_HINT_APPLE                                   0x85BC
#endif //GL_TEXTURE_STORAGE_HINT_APPLE
#ifndef GL_STORAGE_PRIVATE_APPLE
#define GL_STORAGE_PRIVATE_APPLE                                        0x85BD
#endif //GL_STORAGE_PRIVATE_APPLE
#ifndef GL_STORAGE_CACHED_APPLE
#define GL_STORAGE_CACHED_APPLE                                         0x85BE
#endif //GL_STORAGE_CACHED_APPLE
#ifndef GL_STORAGE_SHARED_APPLE
#define GL_STORAGE_SHARED_APPLE                                         0x85BF
#endif //GL_STORAGE_SHARED_APPLE

#endif //GL_APPLE_texture_range


typedef void (*PFNTEXTURERANGEAPPLEPROC_HPP)(GLenum target,GLsizei length,const GLvoid *pointer);

static inline void TextureRangeAPPLE(GLenum target,GLsizei length,const GLvoid *pointer)
{
	static PFNTEXTURERANGEAPPLEPROC_HPP fn=reinterpret_cast<PFNTEXTURERANGEAPPLEPROC_HPP>(_impl::_get_proc_address("glTextureRangeAPPLE","GL_APPLE_texture_range"));
	 fn(target,length,pointer);
}

typedef void (*PFNGETTEXPARAMETERPOINTERVAPPLEPROC_HPP)(GLenum target,GLenum pname,GLvoid* *params);

static inline void GetTexParameterPointervAPPLE(GLenum target,GLenum pname,GLvoid* *params)
{
	static PFNGETTEXPARAMETERPOINTERVAPPLEPROC_HPP fn=reinterpret_cast<PFNGETTEXPARAMETERPOINTERVAPPLEPROC_HPP>(_impl::_get_proc_address("glGetTexParameterPointervAPPLE","GL_APPLE_texture_range"));
	 fn(target,pname,params);
}
#ifndef GL_APPLE_transform_hint

#define GL_APPLE_transform_hint
#ifndef GL_TRANSFORM_HINT_APPLE
#define GL_TRANSFORM_HINT_APPLE                                         0x85B1
#endif //GL_TRANSFORM_HINT_APPLE

#endif //GL_APPLE_transform_hint

#ifndef GL_APPLE_vertex_array_object

#define GL_APPLE_vertex_array_object
#ifndef GL_VERTEX_ARRAY_BINDING_APPLE
#define GL_VERTEX_ARRAY_BINDING_APPLE                                   0x85B5
#endif //GL_VERTEX_ARRAY_BINDING_APPLE

#endif //GL_APPLE_vertex_array_object


typedef void (*PFNBINDVERTEXARRAYAPPLEPROC_HPP)(GLuint array);

static inline void BindVertexArrayAPPLE(GLuint array)
{
	static PFNBINDVERTEXARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNBINDVERTEXARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glBindVertexArrayAPPLE","GL_APPLE_vertex_array_object"));
	 fn(array);
}

typedef void (*PFNDELETEVERTEXARRAYSAPPLEPROC_HPP)(GLsizei n,const GLuint *arrays);

static inline void DeleteVertexArraysAPPLE(GLsizei n,const GLuint *arrays)
{
	static PFNDELETEVERTEXARRAYSAPPLEPROC_HPP fn=reinterpret_cast<PFNDELETEVERTEXARRAYSAPPLEPROC_HPP>(_impl::_get_proc_address("glDeleteVertexArraysAPPLE","GL_APPLE_vertex_array_object"));
	 fn(n,arrays);
}

typedef void (*PFNGENVERTEXARRAYSAPPLEPROC_HPP)(GLsizei n,GLuint *arrays);

static inline void GenVertexArraysAPPLE(GLsizei n,GLuint *arrays)
{
	static PFNGENVERTEXARRAYSAPPLEPROC_HPP fn=reinterpret_cast<PFNGENVERTEXARRAYSAPPLEPROC_HPP>(_impl::_get_proc_address("glGenVertexArraysAPPLE","GL_APPLE_vertex_array_object"));
	 fn(n,arrays);
}

typedef GLboolean (*PFNISVERTEXARRAYAPPLEPROC_HPP)(GLuint array);

static inline GLboolean IsVertexArrayAPPLE(GLuint array)
{
	static PFNISVERTEXARRAYAPPLEPROC_HPP fn=reinterpret_cast<PFNISVERTEXARRAYAPPLEPROC_HPP>(_impl::_get_proc_address("glIsVertexArrayAPPLE","GL_APPLE_vertex_array_object"));
	return fn(array);
}
#ifndef GL_APPLE_vertex_array_range

#define GL_APPLE_vertex_array_range
#ifndef GL_VERTEX_ARRAY_RANGE_APPLE
#define GL_VERTEX_ARRAY_RANGE_APPLE                                     0x851D
#endif //GL_VERTEX_ARRAY_RANGE_APPLE
#ifndef GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE
#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE                              0x851E
#endif //GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE
#ifndef GL_VERTEX_ARRAY_STORAGE_HINT_APPLE
#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE                              0x851F
#endif //GL_VERTEX_ARRAY_STORAGE_HINT_APPLE
#ifndef GL_VERTEX_ARRAY_RANGE_POINTER_APPLE
#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE                             0x8521
#endif //GL_VERTEX_ARRAY_RANGE_POINTER_APPLE
#ifndef GL_STORAGE_CLIENT_APPLE
#define GL_STORAGE_CLIENT_APPLE                                         0x85B4
#endif //GL_STORAGE_CLIENT_APPLE

#endif //GL_APPLE_vertex_array_range


typedef void (*PFNVERTEXARRAYRANGEAPPLEPROC_HPP)(GLsizei length,GLvoid *pointer);

static inline void VertexArrayRangeAPPLE(GLsizei length,GLvoid *pointer)
{
	static PFNVERTEXARRAYRANGEAPPLEPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYRANGEAPPLEPROC_HPP>(_impl::_get_proc_address("glVertexArrayRangeAPPLE","GL_APPLE_vertex_array_range"));
	 fn(length,pointer);
}

typedef void (*PFNFLUSHVERTEXARRAYRANGEAPPLEPROC_HPP)(GLsizei length,GLvoid *pointer);

static inline void FlushVertexArrayRangeAPPLE(GLsizei length,GLvoid *pointer)
{
	static PFNFLUSHVERTEXARRAYRANGEAPPLEPROC_HPP fn=reinterpret_cast<PFNFLUSHVERTEXARRAYRANGEAPPLEPROC_HPP>(_impl::_get_proc_address("glFlushVertexArrayRangeAPPLE","GL_APPLE_vertex_array_range"));
	 fn(length,pointer);
}

typedef void (*PFNVERTEXARRAYPARAMETERIAPPLEPROC_HPP)(GLenum pname,GLint param);

static inline void VertexArrayParameteriAPPLE(GLenum pname,GLint param)
{
	static PFNVERTEXARRAYPARAMETERIAPPLEPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYPARAMETERIAPPLEPROC_HPP>(_impl::_get_proc_address("glVertexArrayParameteriAPPLE","GL_APPLE_vertex_array_range"));
	 fn(pname,param);
}
#ifndef GL_APPLE_vertex_program_evaluators

#define GL_APPLE_vertex_program_evaluators
#ifndef GL_VERTEX_ATTRIB_MAP1_APPLE
#define GL_VERTEX_ATTRIB_MAP1_APPLE                                     0x8A00
#endif //GL_VERTEX_ATTRIB_MAP1_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP2_APPLE
#define GL_VERTEX_ATTRIB_MAP2_APPLE                                     0x8A01
#endif //GL_VERTEX_ATTRIB_MAP2_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE
#define GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE                                0x8A02
#endif //GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE
#define GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE                               0x8A03
#endif //GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE
#define GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE                               0x8A04
#endif //GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE
#define GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE                              0x8A05
#endif //GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE
#define GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE                                0x8A06
#endif //GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE
#define GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE                               0x8A07
#endif //GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE
#define GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE                               0x8A08
#endif //GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE
#ifndef GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE
#define GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE                              0x8A09
#endif //GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE

#endif //GL_APPLE_vertex_program_evaluators


typedef void (*PFNENABLEVERTEXATTRIBAPPLEPROC_HPP)(GLuint index,GLenum pname);

static inline void EnableVertexAttribAPPLE(GLuint index,GLenum pname)
{
	static PFNENABLEVERTEXATTRIBAPPLEPROC_HPP fn=reinterpret_cast<PFNENABLEVERTEXATTRIBAPPLEPROC_HPP>(_impl::_get_proc_address("glEnableVertexAttribAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,pname);
}

typedef void (*PFNDISABLEVERTEXATTRIBAPPLEPROC_HPP)(GLuint index,GLenum pname);

static inline void DisableVertexAttribAPPLE(GLuint index,GLenum pname)
{
	static PFNDISABLEVERTEXATTRIBAPPLEPROC_HPP fn=reinterpret_cast<PFNDISABLEVERTEXATTRIBAPPLEPROC_HPP>(_impl::_get_proc_address("glDisableVertexAttribAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,pname);
}

typedef GLboolean (*PFNISVERTEXATTRIBENABLEDAPPLEPROC_HPP)(GLuint index,GLenum pname);

static inline GLboolean IsVertexAttribEnabledAPPLE(GLuint index,GLenum pname)
{
	static PFNISVERTEXATTRIBENABLEDAPPLEPROC_HPP fn=reinterpret_cast<PFNISVERTEXATTRIBENABLEDAPPLEPROC_HPP>(_impl::_get_proc_address("glIsVertexAttribEnabledAPPLE","GL_APPLE_vertex_program_evaluators"));
	return fn(index,pname);
}

typedef void (*PFNMAPVERTEXATTRIB1DAPPLEPROC_HPP)(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble *points);

static inline void MapVertexAttrib1dAPPLE(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble *points)
{
	static PFNMAPVERTEXATTRIB1DAPPLEPROC_HPP fn=reinterpret_cast<PFNMAPVERTEXATTRIB1DAPPLEPROC_HPP>(_impl::_get_proc_address("glMapVertexAttrib1dAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,size,u1,u2,stride,order,points);
}

typedef void (*PFNMAPVERTEXATTRIB1FAPPLEPROC_HPP)(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat *points);

static inline void MapVertexAttrib1fAPPLE(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat *points)
{
	static PFNMAPVERTEXATTRIB1FAPPLEPROC_HPP fn=reinterpret_cast<PFNMAPVERTEXATTRIB1FAPPLEPROC_HPP>(_impl::_get_proc_address("glMapVertexAttrib1fAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,size,u1,u2,stride,order,points);
}

typedef void (*PFNMAPVERTEXATTRIB2DAPPLEPROC_HPP)(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble *points);

static inline void MapVertexAttrib2dAPPLE(GLuint index,GLuint size,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble *points)
{
	static PFNMAPVERTEXATTRIB2DAPPLEPROC_HPP fn=reinterpret_cast<PFNMAPVERTEXATTRIB2DAPPLEPROC_HPP>(_impl::_get_proc_address("glMapVertexAttrib2dAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,size,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
}

typedef void (*PFNMAPVERTEXATTRIB2FAPPLEPROC_HPP)(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat *points);

static inline void MapVertexAttrib2fAPPLE(GLuint index,GLuint size,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat *points)
{
	static PFNMAPVERTEXATTRIB2FAPPLEPROC_HPP fn=reinterpret_cast<PFNMAPVERTEXATTRIB2FAPPLEPROC_HPP>(_impl::_get_proc_address("glMapVertexAttrib2fAPPLE","GL_APPLE_vertex_program_evaluators"));
	 fn(index,size,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points);
}
#ifndef GL_APPLE_ycbcr_422

#define GL_APPLE_ycbcr_422
#ifndef GL_YCBCR_422_APPLE
#define GL_YCBCR_422_APPLE                                              0x85B9
#endif //GL_YCBCR_422_APPLE

#endif //GL_APPLE_ycbcr_422

#ifndef GL_ARB_ES2_compatibility

#define GL_ARB_ES2_compatibility
#ifndef GL_FIXED
#define GL_FIXED                                                        0x140C
#endif //GL_FIXED
#ifndef GL_IMPLEMENTATION_COLOR_READ_TYPE
#define GL_IMPLEMENTATION_COLOR_READ_TYPE                               0x8B9A
#endif //GL_IMPLEMENTATION_COLOR_READ_TYPE
#ifndef GL_IMPLEMENTATION_COLOR_READ_FORMAT
#define GL_IMPLEMENTATION_COLOR_READ_FORMAT                             0x8B9B
#endif //GL_IMPLEMENTATION_COLOR_READ_FORMAT
#ifndef GL_RGB565
#define GL_RGB565                                                       0x8D62
#endif //GL_RGB565
#ifndef GL_LOW_FLOAT
#define GL_LOW_FLOAT                                                    0x8DF0
#endif //GL_LOW_FLOAT
#ifndef GL_MEDIUM_FLOAT
#define GL_MEDIUM_FLOAT                                                 0x8DF1
#endif //GL_MEDIUM_FLOAT
#ifndef GL_HIGH_FLOAT
#define GL_HIGH_FLOAT                                                   0x8DF2
#endif //GL_HIGH_FLOAT
#ifndef GL_LOW_INT
#define GL_LOW_INT                                                      0x8DF3
#endif //GL_LOW_INT
#ifndef GL_MEDIUM_INT
#define GL_MEDIUM_INT                                                   0x8DF4
#endif //GL_MEDIUM_INT
#ifndef GL_HIGH_INT
#define GL_HIGH_INT                                                     0x8DF5
#endif //GL_HIGH_INT
#ifndef GL_SHADER_BINARY_FORMATS
#define GL_SHADER_BINARY_FORMATS                                        0x8DF8
#endif //GL_SHADER_BINARY_FORMATS
#ifndef GL_NUM_SHADER_BINARY_FORMATS
#define GL_NUM_SHADER_BINARY_FORMATS                                    0x8DF9
#endif //GL_NUM_SHADER_BINARY_FORMATS
#ifndef GL_SHADER_COMPILER
#define GL_SHADER_COMPILER                                              0x8DFA
#endif //GL_SHADER_COMPILER
#ifndef GL_MAX_VERTEX_UNIFORM_VECTORS
#define GL_MAX_VERTEX_UNIFORM_VECTORS                                   0x8DFB
#endif //GL_MAX_VERTEX_UNIFORM_VECTORS
#ifndef GL_MAX_VARYING_VECTORS
#define GL_MAX_VARYING_VECTORS                                          0x8DFC
#endif //GL_MAX_VARYING_VECTORS
#ifndef GL_MAX_FRAGMENT_UNIFORM_VECTORS
#define GL_MAX_FRAGMENT_UNIFORM_VECTORS                                 0x8DFD
#endif //GL_MAX_FRAGMENT_UNIFORM_VECTORS

#endif //GL_ARB_ES2_compatibility


typedef void (*PFNRELEASESHADERCOMPILERPROC_HPP)();

static inline void ReleaseShaderCompiler()
{
	static PFNRELEASESHADERCOMPILERPROC_HPP fn=reinterpret_cast<PFNRELEASESHADERCOMPILERPROC_HPP>(_impl::_get_proc_address("glReleaseShaderCompiler","GL_ARB_ES2_compatibility"));
	 fn();
}

typedef void (*PFNSHADERBINARYPROC_HPP)(GLsizei count,const GLuint *shaders,GLenum binaryformat,const GLvoid *binary,GLsizei length);

static inline void ShaderBinary(GLsizei count,const GLuint *shaders,GLenum binaryformat,const GLvoid *binary,GLsizei length)
{
	static PFNSHADERBINARYPROC_HPP fn=reinterpret_cast<PFNSHADERBINARYPROC_HPP>(_impl::_get_proc_address("glShaderBinary","GL_ARB_ES2_compatibility"));
	 fn(count,shaders,binaryformat,binary,length);
}

typedef void (*PFNGETSHADERPRECISIONFORMATPROC_HPP)(GLenum shadertype,GLenum precisiontype,GLint *range,GLint *precision);

static inline void GetShaderPrecisionFormat(GLenum shadertype,GLenum precisiontype,GLint *range,GLint *precision)
{
	static PFNGETSHADERPRECISIONFORMATPROC_HPP fn=reinterpret_cast<PFNGETSHADERPRECISIONFORMATPROC_HPP>(_impl::_get_proc_address("glGetShaderPrecisionFormat","GL_ARB_ES2_compatibility"));
	 fn(shadertype,precisiontype,range,precision);
}

typedef void (*PFNDEPTHRANGEFPROC_HPP)(GLfloat n,GLfloat f);

static inline void DepthRangef(GLfloat n,GLfloat f)
{
	static PFNDEPTHRANGEFPROC_HPP fn=reinterpret_cast<PFNDEPTHRANGEFPROC_HPP>(_impl::_get_proc_address("glDepthRangef","GL_ARB_ES2_compatibility"));
	 fn(n,f);
}

typedef void (*PFNCLEARDEPTHFPROC_HPP)(GLfloat d);

static inline void ClearDepthf(GLfloat d)
{
	static PFNCLEARDEPTHFPROC_HPP fn=reinterpret_cast<PFNCLEARDEPTHFPROC_HPP>(_impl::_get_proc_address("glClearDepthf","GL_ARB_ES2_compatibility"));
	 fn(d);
}
#ifndef GL_ARB_ES3_compatibility

#define GL_ARB_ES3_compatibility
#ifndef GL_PRIMITIVE_RESTART_FIXED_INDEX
#define GL_PRIMITIVE_RESTART_FIXED_INDEX                                0x8D69
#endif //GL_PRIMITIVE_RESTART_FIXED_INDEX
#ifndef GL_ANY_SAMPLES_PASSED_CONSERVATIVE
#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE                              0x8D6A
#endif //GL_ANY_SAMPLES_PASSED_CONSERVATIVE
#ifndef GL_MAX_ELEMENT_INDEX
#define GL_MAX_ELEMENT_INDEX                                            0x8D6B
#endif //GL_MAX_ELEMENT_INDEX
#ifndef GL_COMPRESSED_R11_EAC
#define GL_COMPRESSED_R11_EAC                                           0x9270
#endif //GL_COMPRESSED_R11_EAC
#ifndef GL_COMPRESSED_SIGNED_R11_EAC
#define GL_COMPRESSED_SIGNED_R11_EAC                                    0x9271
#endif //GL_COMPRESSED_SIGNED_R11_EAC
#ifndef GL_COMPRESSED_RG11_EAC
#define GL_COMPRESSED_RG11_EAC                                          0x9272
#endif //GL_COMPRESSED_RG11_EAC
#ifndef GL_COMPRESSED_SIGNED_RG11_EAC
#define GL_COMPRESSED_SIGNED_RG11_EAC                                   0x9273
#endif //GL_COMPRESSED_SIGNED_RG11_EAC
#ifndef GL_COMPRESSED_RGB8_ETC2
#define GL_COMPRESSED_RGB8_ETC2                                         0x9274
#endif //GL_COMPRESSED_RGB8_ETC2
#ifndef GL_COMPRESSED_SRGB8_ETC2
#define GL_COMPRESSED_SRGB8_ETC2                                        0x9275
#endif //GL_COMPRESSED_SRGB8_ETC2
#ifndef GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2                     0x9276
#endif //GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
#ifndef GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2                    0x9277
#endif //GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC
#define GL_COMPRESSED_RGBA8_ETC2_EAC                                    0x9278
#endif //GL_COMPRESSED_RGBA8_ETC2_EAC
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC                             0x9279
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC

#endif //GL_ARB_ES3_compatibility

#ifndef GL_ARB_base_instance

#define GL_ARB_base_instance

#endif //GL_ARB_base_instance


typedef void (*PFNDRAWARRAYSINSTANCEDBASEINSTANCEPROC_HPP)(GLenum mode,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance);

static inline void DrawArraysInstancedBaseInstance(GLenum mode,GLint first,GLsizei count,GLsizei instancecount,GLuint baseinstance)
{
	static PFNDRAWARRAYSINSTANCEDBASEINSTANCEPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSINSTANCEDBASEINSTANCEPROC_HPP>(_impl::_get_proc_address("glDrawArraysInstancedBaseInstance","GL_ARB_base_instance"));
	 fn(mode,first,count,instancecount,baseinstance);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDBASEINSTANCEPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const void *indices,GLsizei instancecount,GLuint baseinstance);

static inline void DrawElementsInstancedBaseInstance(GLenum mode,GLsizei count,GLenum type,const void *indices,GLsizei instancecount,GLuint baseinstance)
{
	static PFNDRAWELEMENTSINSTANCEDBASEINSTANCEPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDBASEINSTANCEPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstancedBaseInstance","GL_ARB_base_instance"));
	 fn(mode,count,type,indices,instancecount,baseinstance);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const void *indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance);

static inline void DrawElementsInstancedBaseVertexBaseInstance(GLenum mode,GLsizei count,GLenum type,const void *indices,GLsizei instancecount,GLint basevertex,GLuint baseinstance)
{
	static PFNDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstancedBaseVertexBaseInstance","GL_ARB_base_instance"));
	 fn(mode,count,type,indices,instancecount,basevertex,baseinstance);
}
#ifndef GL_ARB_blend_func_extended

#define GL_ARB_blend_func_extended
#ifndef GL_SRC1_COLOR
#define GL_SRC1_COLOR                                                   0x88F9
#endif //GL_SRC1_COLOR
#ifndef GL_ONE_MINUS_SRC1_COLOR
#define GL_ONE_MINUS_SRC1_COLOR                                         0x88FA
#endif //GL_ONE_MINUS_SRC1_COLOR
#ifndef GL_ONE_MINUS_SRC1_ALPHA
#define GL_ONE_MINUS_SRC1_ALPHA                                         0x88FB
#endif //GL_ONE_MINUS_SRC1_ALPHA
#ifndef GL_MAX_DUAL_SOURCE_DRAW_BUFFERS
#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS                                 0x88FC
#endif //GL_MAX_DUAL_SOURCE_DRAW_BUFFERS

#endif //GL_ARB_blend_func_extended


typedef void (*PFNBINDFRAGDATALOCATIONINDEXEDPROC_HPP)(GLuint program,GLuint colorNumber,GLuint index,const GLchar *name);

static inline void BindFragDataLocationIndexed(GLuint program,GLuint colorNumber,GLuint index,const GLchar *name)
{
	static PFNBINDFRAGDATALOCATIONINDEXEDPROC_HPP fn=reinterpret_cast<PFNBINDFRAGDATALOCATIONINDEXEDPROC_HPP>(_impl::_get_proc_address("glBindFragDataLocationIndexed","GL_ARB_blend_func_extended"));
	 fn(program,colorNumber,index,name);
}

typedef GLint (*PFNGETFRAGDATAINDEXPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetFragDataIndex(GLuint program,const GLchar *name)
{
	static PFNGETFRAGDATAINDEXPROC_HPP fn=reinterpret_cast<PFNGETFRAGDATAINDEXPROC_HPP>(_impl::_get_proc_address("glGetFragDataIndex","GL_ARB_blend_func_extended"));
	return fn(program,name);
}
#ifndef GL_ARB_cl_event

#define GL_ARB_cl_event
#ifndef GL_SYNC_CL_EVENT_ARB
#define GL_SYNC_CL_EVENT_ARB                                            0x8240
#endif //GL_SYNC_CL_EVENT_ARB
#ifndef GL_SYNC_CL_EVENT_COMPLETE_ARB
#define GL_SYNC_CL_EVENT_COMPLETE_ARB                                   0x8241
#endif //GL_SYNC_CL_EVENT_COMPLETE_ARB

#endif //GL_ARB_cl_event


typedef GLsync (*PFNCREATESYNCFROMCLEVENTARBPROC_HPP)(struct _cl_context * context,struct _cl_event * event,GLbitfield flags);

static inline GLsync CreateSyncFromCLeventARB(struct _cl_context * context,struct _cl_event * event,GLbitfield flags)
{
	static PFNCREATESYNCFROMCLEVENTARBPROC_HPP fn=reinterpret_cast<PFNCREATESYNCFROMCLEVENTARBPROC_HPP>(_impl::_get_proc_address("glCreateSyncFromCLeventARB","GL_ARB_cl_event"));
	return fn(context,event,flags);
}
#ifndef GL_ARB_clear_buffer_object

#define GL_ARB_clear_buffer_object

#endif //GL_ARB_clear_buffer_object


typedef void (*PFNCLEARBUFFERDATAPROC_HPP)(GLenum target,GLenum internalformat,GLenum format,GLenum type,const void *data);

static inline void ClearBufferData(GLenum target,GLenum internalformat,GLenum format,GLenum type,const void *data)
{
	static PFNCLEARBUFFERDATAPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERDATAPROC_HPP>(_impl::_get_proc_address("glClearBufferData","GL_ARB_clear_buffer_object"));
	 fn(target,internalformat,format,type,data);
}

typedef void (*PFNCLEARBUFFERSUBDATAPROC_HPP)(GLenum target,GLenum internalformat,GLintptr offset,GLsizeiptr size,GLenum format,GLenum type,const void *data);

static inline void ClearBufferSubData(GLenum target,GLenum internalformat,GLintptr offset,GLsizeiptr size,GLenum format,GLenum type,const void *data)
{
	static PFNCLEARBUFFERSUBDATAPROC_HPP fn=reinterpret_cast<PFNCLEARBUFFERSUBDATAPROC_HPP>(_impl::_get_proc_address("glClearBufferSubData","GL_ARB_clear_buffer_object"));
	 fn(target,internalformat,offset,size,format,type,data);
}

typedef void (*PFNCLEARNAMEDBUFFERDATAEXTPROC_HPP)(GLuint buffer,GLenum internalformat,GLenum format,GLenum type,const void *data);

static inline void ClearNamedBufferDataEXT(GLuint buffer,GLenum internalformat,GLenum format,GLenum type,const void *data)
{
	static PFNCLEARNAMEDBUFFERDATAEXTPROC_HPP fn=reinterpret_cast<PFNCLEARNAMEDBUFFERDATAEXTPROC_HPP>(_impl::_get_proc_address("glClearNamedBufferDataEXT","GL_ARB_clear_buffer_object"));
	 fn(buffer,internalformat,format,type,data);
}

typedef void (*PFNCLEARNAMEDBUFFERSUBDATAEXTPROC_HPP)(GLuint buffer,GLenum internalformat,GLsizeiptr offset,GLsizeiptr size,GLenum format,GLenum type,const void *data);

static inline void ClearNamedBufferSubDataEXT(GLuint buffer,GLenum internalformat,GLsizeiptr offset,GLsizeiptr size,GLenum format,GLenum type,const void *data)
{
	static PFNCLEARNAMEDBUFFERSUBDATAEXTPROC_HPP fn=reinterpret_cast<PFNCLEARNAMEDBUFFERSUBDATAEXTPROC_HPP>(_impl::_get_proc_address("glClearNamedBufferSubDataEXT","GL_ARB_clear_buffer_object"));
	 fn(buffer,internalformat,offset,size,format,type,data);
}
#ifndef GL_ARB_color_buffer_float

#define GL_ARB_color_buffer_float
#ifndef GL_RGBA_FLOAT_MODE_ARB
#define GL_RGBA_FLOAT_MODE_ARB                                          0x8820
#endif //GL_RGBA_FLOAT_MODE_ARB
#ifndef GL_CLAMP_VERTEX_COLOR_ARB
#define GL_CLAMP_VERTEX_COLOR_ARB                                       0x891A
#endif //GL_CLAMP_VERTEX_COLOR_ARB
#ifndef GL_CLAMP_FRAGMENT_COLOR_ARB
#define GL_CLAMP_FRAGMENT_COLOR_ARB                                     0x891B
#endif //GL_CLAMP_FRAGMENT_COLOR_ARB
#ifndef GL_CLAMP_READ_COLOR_ARB
#define GL_CLAMP_READ_COLOR_ARB                                         0x891C
#endif //GL_CLAMP_READ_COLOR_ARB
#ifndef GL_FIXED_ONLY_ARB
#define GL_FIXED_ONLY_ARB                                               0x891D
#endif //GL_FIXED_ONLY_ARB

#endif //GL_ARB_color_buffer_float


typedef void (*PFNCLAMPCOLORARBPROC_HPP)(GLenum target,GLenum clamp);

static inline void ClampColorARB(GLenum target,GLenum clamp)
{
	static PFNCLAMPCOLORARBPROC_HPP fn=reinterpret_cast<PFNCLAMPCOLORARBPROC_HPP>(_impl::_get_proc_address("glClampColorARB","GL_ARB_color_buffer_float"));
	 fn(target,clamp);
}
#ifndef GL_ARB_compressed_texture_pixel_storage

#define GL_ARB_compressed_texture_pixel_storage
#ifndef GL_UNPACK_COMPRESSED_BLOCK_WIDTH
#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH                                0x9127
#endif //GL_UNPACK_COMPRESSED_BLOCK_WIDTH
#ifndef GL_UNPACK_COMPRESSED_BLOCK_HEIGHT
#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT                               0x9128
#endif //GL_UNPACK_COMPRESSED_BLOCK_HEIGHT
#ifndef GL_UNPACK_COMPRESSED_BLOCK_DEPTH
#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH                                0x9129
#endif //GL_UNPACK_COMPRESSED_BLOCK_DEPTH
#ifndef GL_UNPACK_COMPRESSED_BLOCK_SIZE
#define GL_UNPACK_COMPRESSED_BLOCK_SIZE                                 0x912A
#endif //GL_UNPACK_COMPRESSED_BLOCK_SIZE
#ifndef GL_PACK_COMPRESSED_BLOCK_WIDTH
#define GL_PACK_COMPRESSED_BLOCK_WIDTH                                  0x912B
#endif //GL_PACK_COMPRESSED_BLOCK_WIDTH
#ifndef GL_PACK_COMPRESSED_BLOCK_HEIGHT
#define GL_PACK_COMPRESSED_BLOCK_HEIGHT                                 0x912C
#endif //GL_PACK_COMPRESSED_BLOCK_HEIGHT
#ifndef GL_PACK_COMPRESSED_BLOCK_DEPTH
#define GL_PACK_COMPRESSED_BLOCK_DEPTH                                  0x912D
#endif //GL_PACK_COMPRESSED_BLOCK_DEPTH
#ifndef GL_PACK_COMPRESSED_BLOCK_SIZE
#define GL_PACK_COMPRESSED_BLOCK_SIZE                                   0x912E
#endif //GL_PACK_COMPRESSED_BLOCK_SIZE

#endif //GL_ARB_compressed_texture_pixel_storage

#ifndef GL_ARB_compute_shader

#define GL_ARB_compute_shader
#ifndef GL_COMPUTE_SHADER_BIT
#define GL_COMPUTE_SHADER_BIT                                           0x00000020
#endif //GL_COMPUTE_SHADER_BIT
#ifndef GL_MAX_COMPUTE_SHARED_MEMORY_SIZE
#define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE                               0x8262
#endif //GL_MAX_COMPUTE_SHARED_MEMORY_SIZE
#ifndef GL_MAX_COMPUTE_UNIFORM_COMPONENTS
#define GL_MAX_COMPUTE_UNIFORM_COMPONENTS                               0x8263
#endif //GL_MAX_COMPUTE_UNIFORM_COMPONENTS
#ifndef GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS                           0x8264
#endif //GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_COMPUTE_ATOMIC_COUNTERS
#define GL_MAX_COMPUTE_ATOMIC_COUNTERS                                  0x8265
#endif //GL_MAX_COMPUTE_ATOMIC_COUNTERS
#ifndef GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS                      0x8266
#endif //GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS
#ifndef GL_COMPUTE_LOCAL_WORK_SIZE
#define GL_COMPUTE_LOCAL_WORK_SIZE                                      0x8267
#endif //GL_COMPUTE_LOCAL_WORK_SIZE
#ifndef GL_MAX_COMPUTE_LOCAL_INVOCATIONS
#define GL_MAX_COMPUTE_LOCAL_INVOCATIONS                                0x90EB
#endif //GL_MAX_COMPUTE_LOCAL_INVOCATIONS
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER                   0x90EC
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER           0x90ED
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER
#ifndef GL_DISPATCH_INDIRECT_BUFFER
#define GL_DISPATCH_INDIRECT_BUFFER                                     0x90EE
#endif //GL_DISPATCH_INDIRECT_BUFFER
#ifndef GL_DISPATCH_INDIRECT_BUFFER_BINDING
#define GL_DISPATCH_INDIRECT_BUFFER_BINDING                             0x90EF
#endif //GL_DISPATCH_INDIRECT_BUFFER_BINDING
#ifndef GL_COMPUTE_SHADER
#define GL_COMPUTE_SHADER                                               0x91B9
#endif //GL_COMPUTE_SHADER
#ifndef GL_MAX_COMPUTE_UNIFORM_BLOCKS
#define GL_MAX_COMPUTE_UNIFORM_BLOCKS                                   0x91BB
#endif //GL_MAX_COMPUTE_UNIFORM_BLOCKS
#ifndef GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS
#define GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS                              0x91BC
#endif //GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS
#ifndef GL_MAX_COMPUTE_IMAGE_UNIFORMS
#define GL_MAX_COMPUTE_IMAGE_UNIFORMS                                   0x91BD
#endif //GL_MAX_COMPUTE_IMAGE_UNIFORMS
#ifndef GL_MAX_COMPUTE_WORK_GROUP_COUNT
#define GL_MAX_COMPUTE_WORK_GROUP_COUNT                                 0x91BE
#endif //GL_MAX_COMPUTE_WORK_GROUP_COUNT
#ifndef GL_MAX_COMPUTE_WORK_GROUP_SIZE
#define GL_MAX_COMPUTE_WORK_GROUP_SIZE                                  0x91BF
#endif //GL_MAX_COMPUTE_WORK_GROUP_SIZE

#endif //GL_ARB_compute_shader


typedef void (*PFNDISPATCHCOMPUTEPROC_HPP)(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z);

static inline void DispatchCompute(GLuint num_groups_x,GLuint num_groups_y,GLuint num_groups_z)
{
	static PFNDISPATCHCOMPUTEPROC_HPP fn=reinterpret_cast<PFNDISPATCHCOMPUTEPROC_HPP>(_impl::_get_proc_address("glDispatchCompute","GL_ARB_compute_shader"));
	 fn(num_groups_x,num_groups_y,num_groups_z);
}

typedef void (*PFNDISPATCHCOMPUTEINDIRECTPROC_HPP)(GLintptr indirect);

static inline void DispatchComputeIndirect(GLintptr indirect)
{
	static PFNDISPATCHCOMPUTEINDIRECTPROC_HPP fn=reinterpret_cast<PFNDISPATCHCOMPUTEINDIRECTPROC_HPP>(_impl::_get_proc_address("glDispatchComputeIndirect","GL_ARB_compute_shader"));
	 fn(indirect);
}
#ifndef GL_ARB_copy_buffer

#define GL_ARB_copy_buffer
#ifndef GL_COPY_READ_BUFFER_BINDING
#define GL_COPY_READ_BUFFER_BINDING                                     0x8F36
#endif //GL_COPY_READ_BUFFER_BINDING
#ifndef GL_COPY_WRITE_BUFFER_BINDING
#define GL_COPY_WRITE_BUFFER_BINDING                                    0x8F37
#endif //GL_COPY_WRITE_BUFFER_BINDING

#endif //GL_ARB_copy_buffer


typedef void (*PFNCOPYBUFFERSUBDATAPROC_HPP)(GLenum readTarget,GLenum writeTarget,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);

static inline void CopyBufferSubData(GLenum readTarget,GLenum writeTarget,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size)
{
	static PFNCOPYBUFFERSUBDATAPROC_HPP fn=reinterpret_cast<PFNCOPYBUFFERSUBDATAPROC_HPP>(_impl::_get_proc_address("glCopyBufferSubData","GL_ARB_copy_buffer"));
	 fn(readTarget,writeTarget,readOffset,writeOffset,size);
}
#ifndef GL_ARB_copy_image

#define GL_ARB_copy_image

#endif //GL_ARB_copy_image


typedef void (*PFNCOPYIMAGESUBDATAPROC_HPP)(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth);

static inline void CopyImageSubData(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei srcWidth,GLsizei srcHeight,GLsizei srcDepth)
{
	static PFNCOPYIMAGESUBDATAPROC_HPP fn=reinterpret_cast<PFNCOPYIMAGESUBDATAPROC_HPP>(_impl::_get_proc_address("glCopyImageSubData","GL_ARB_copy_image"));
	 fn(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth);
}
#ifndef GL_ARB_debug_output

#define GL_ARB_debug_output
#ifndef GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
#define GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB                                 0x8242
#endif //GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
#ifndef GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB
#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB                         0x8243
#endif //GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB
#ifndef GL_DEBUG_CALLBACK_FUNCTION_ARB
#define GL_DEBUG_CALLBACK_FUNCTION_ARB                                  0x8244
#endif //GL_DEBUG_CALLBACK_FUNCTION_ARB
#ifndef GL_DEBUG_CALLBACK_USER_PARAM_ARB
#define GL_DEBUG_CALLBACK_USER_PARAM_ARB                                0x8245
#endif //GL_DEBUG_CALLBACK_USER_PARAM_ARB
#ifndef GL_DEBUG_SOURCE_API_ARB
#define GL_DEBUG_SOURCE_API_ARB                                         0x8246
#endif //GL_DEBUG_SOURCE_API_ARB
#ifndef GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB
#define GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB                               0x8247
#endif //GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB
#ifndef GL_DEBUG_SOURCE_SHADER_COMPILER_ARB
#define GL_DEBUG_SOURCE_SHADER_COMPILER_ARB                             0x8248
#endif //GL_DEBUG_SOURCE_SHADER_COMPILER_ARB
#ifndef GL_DEBUG_SOURCE_THIRD_PARTY_ARB
#define GL_DEBUG_SOURCE_THIRD_PARTY_ARB                                 0x8249
#endif //GL_DEBUG_SOURCE_THIRD_PARTY_ARB
#ifndef GL_DEBUG_SOURCE_APPLICATION_ARB
#define GL_DEBUG_SOURCE_APPLICATION_ARB                                 0x824A
#endif //GL_DEBUG_SOURCE_APPLICATION_ARB
#ifndef GL_DEBUG_SOURCE_OTHER_ARB
#define GL_DEBUG_SOURCE_OTHER_ARB                                       0x824B
#endif //GL_DEBUG_SOURCE_OTHER_ARB
#ifndef GL_DEBUG_TYPE_ERROR_ARB
#define GL_DEBUG_TYPE_ERROR_ARB                                         0x824C
#endif //GL_DEBUG_TYPE_ERROR_ARB
#ifndef GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB
#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB                           0x824D
#endif //GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB
#ifndef GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB
#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB                            0x824E
#endif //GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB
#ifndef GL_DEBUG_TYPE_PORTABILITY_ARB
#define GL_DEBUG_TYPE_PORTABILITY_ARB                                   0x824F
#endif //GL_DEBUG_TYPE_PORTABILITY_ARB
#ifndef GL_DEBUG_TYPE_PERFORMANCE_ARB
#define GL_DEBUG_TYPE_PERFORMANCE_ARB                                   0x8250
#endif //GL_DEBUG_TYPE_PERFORMANCE_ARB
#ifndef GL_DEBUG_TYPE_OTHER_ARB
#define GL_DEBUG_TYPE_OTHER_ARB                                         0x8251
#endif //GL_DEBUG_TYPE_OTHER_ARB
#ifndef GL_MAX_DEBUG_MESSAGE_LENGTH_ARB
#define GL_MAX_DEBUG_MESSAGE_LENGTH_ARB                                 0x9143
#endif //GL_MAX_DEBUG_MESSAGE_LENGTH_ARB
#ifndef GL_MAX_DEBUG_LOGGED_MESSAGES_ARB
#define GL_MAX_DEBUG_LOGGED_MESSAGES_ARB                                0x9144
#endif //GL_MAX_DEBUG_LOGGED_MESSAGES_ARB
#ifndef GL_DEBUG_LOGGED_MESSAGES_ARB
#define GL_DEBUG_LOGGED_MESSAGES_ARB                                    0x9145
#endif //GL_DEBUG_LOGGED_MESSAGES_ARB
#ifndef GL_DEBUG_SEVERITY_HIGH_ARB
#define GL_DEBUG_SEVERITY_HIGH_ARB                                      0x9146
#endif //GL_DEBUG_SEVERITY_HIGH_ARB
#ifndef GL_DEBUG_SEVERITY_MEDIUM_ARB
#define GL_DEBUG_SEVERITY_MEDIUM_ARB                                    0x9147
#endif //GL_DEBUG_SEVERITY_MEDIUM_ARB
#ifndef GL_DEBUG_SEVERITY_LOW_ARB
#define GL_DEBUG_SEVERITY_LOW_ARB                                       0x9148
#endif //GL_DEBUG_SEVERITY_LOW_ARB

#endif //GL_ARB_debug_output


typedef void (*PFNDEBUGMESSAGECONTROLARBPROC_HPP)(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled);

static inline void DebugMessageControlARB(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled)
{
	static PFNDEBUGMESSAGECONTROLARBPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGECONTROLARBPROC_HPP>(_impl::_get_proc_address("glDebugMessageControlARB","GL_ARB_debug_output"));
	 fn(source,type,severity,count,ids,enabled);
}

typedef void (*PFNDEBUGMESSAGEINSERTARBPROC_HPP)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *buf);

static inline void DebugMessageInsertARB(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *buf)
{
	static PFNDEBUGMESSAGEINSERTARBPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGEINSERTARBPROC_HPP>(_impl::_get_proc_address("glDebugMessageInsertARB","GL_ARB_debug_output"));
	 fn(source,type,id,severity,length,buf);
}

typedef void (*PFNDEBUGMESSAGECALLBACKARBPROC_HPP)(GLDEBUGPROCARB callback,const GLvoid *userParam);

static inline void DebugMessageCallbackARB(GLDEBUGPROCARB callback,const GLvoid *userParam)
{
	static PFNDEBUGMESSAGECALLBACKARBPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGECALLBACKARBPROC_HPP>(_impl::_get_proc_address("glDebugMessageCallbackARB","GL_ARB_debug_output"));
	 fn(callback,userParam);
}

typedef GLuint (*PFNGETDEBUGMESSAGELOGARBPROC_HPP)(GLuint count,GLsizei bufsize,GLenum *sources,GLenum *types,GLuint *ids,GLenum *severities,GLsizei *lengths,GLchar *messageLog);

static inline GLuint GetDebugMessageLogARB(GLuint count,GLsizei bufsize,GLenum *sources,GLenum *types,GLuint *ids,GLenum *severities,GLsizei *lengths,GLchar *messageLog)
{
	static PFNGETDEBUGMESSAGELOGARBPROC_HPP fn=reinterpret_cast<PFNGETDEBUGMESSAGELOGARBPROC_HPP>(_impl::_get_proc_address("glGetDebugMessageLogARB","GL_ARB_debug_output"));
	return fn(count,bufsize,sources,types,ids,severities,lengths,messageLog);
}
#ifndef GL_ARB_depth_buffer_float

#define GL_ARB_depth_buffer_float
#ifndef GL_DEPTH_COMPONENT32F
#define GL_DEPTH_COMPONENT32F                                           0x8CAC
#endif //GL_DEPTH_COMPONENT32F
#ifndef GL_DEPTH32F_STENCIL8
#define GL_DEPTH32F_STENCIL8                                            0x8CAD
#endif //GL_DEPTH32F_STENCIL8
#ifndef GL_FLOAT_32_UNSIGNED_INT_24_8_REV
#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV                               0x8DAD
#endif //GL_FLOAT_32_UNSIGNED_INT_24_8_REV

#endif //GL_ARB_depth_buffer_float

#ifndef GL_ARB_depth_clamp

#define GL_ARB_depth_clamp

#endif //GL_ARB_depth_clamp

#ifndef GL_ARB_depth_texture

#define GL_ARB_depth_texture
#ifndef GL_DEPTH_COMPONENT16_ARB
#define GL_DEPTH_COMPONENT16_ARB                                        0x81A5
#endif //GL_DEPTH_COMPONENT16_ARB
#ifndef GL_DEPTH_COMPONENT24_ARB
#define GL_DEPTH_COMPONENT24_ARB                                        0x81A6
#endif //GL_DEPTH_COMPONENT24_ARB
#ifndef GL_DEPTH_COMPONENT32_ARB
#define GL_DEPTH_COMPONENT32_ARB                                        0x81A7
#endif //GL_DEPTH_COMPONENT32_ARB
#ifndef GL_TEXTURE_DEPTH_SIZE_ARB
#define GL_TEXTURE_DEPTH_SIZE_ARB                                       0x884A
#endif //GL_TEXTURE_DEPTH_SIZE_ARB
#ifndef GL_DEPTH_TEXTURE_MODE_ARB
#define GL_DEPTH_TEXTURE_MODE_ARB                                       0x884B
#endif //GL_DEPTH_TEXTURE_MODE_ARB

#endif //GL_ARB_depth_texture

#ifndef GL_ARB_draw_buffers

#define GL_ARB_draw_buffers
#ifndef GL_MAX_DRAW_BUFFERS_ARB
#define GL_MAX_DRAW_BUFFERS_ARB                                         0x8824
#endif //GL_MAX_DRAW_BUFFERS_ARB
#ifndef GL_DRAW_BUFFER0_ARB
#define GL_DRAW_BUFFER0_ARB                                             0x8825
#endif //GL_DRAW_BUFFER0_ARB
#ifndef GL_DRAW_BUFFER1_ARB
#define GL_DRAW_BUFFER1_ARB                                             0x8826
#endif //GL_DRAW_BUFFER1_ARB
#ifndef GL_DRAW_BUFFER2_ARB
#define GL_DRAW_BUFFER2_ARB                                             0x8827
#endif //GL_DRAW_BUFFER2_ARB
#ifndef GL_DRAW_BUFFER3_ARB
#define GL_DRAW_BUFFER3_ARB                                             0x8828
#endif //GL_DRAW_BUFFER3_ARB
#ifndef GL_DRAW_BUFFER4_ARB
#define GL_DRAW_BUFFER4_ARB                                             0x8829
#endif //GL_DRAW_BUFFER4_ARB
#ifndef GL_DRAW_BUFFER5_ARB
#define GL_DRAW_BUFFER5_ARB                                             0x882A
#endif //GL_DRAW_BUFFER5_ARB
#ifndef GL_DRAW_BUFFER6_ARB
#define GL_DRAW_BUFFER6_ARB                                             0x882B
#endif //GL_DRAW_BUFFER6_ARB
#ifndef GL_DRAW_BUFFER7_ARB
#define GL_DRAW_BUFFER7_ARB                                             0x882C
#endif //GL_DRAW_BUFFER7_ARB
#ifndef GL_DRAW_BUFFER8_ARB
#define GL_DRAW_BUFFER8_ARB                                             0x882D
#endif //GL_DRAW_BUFFER8_ARB
#ifndef GL_DRAW_BUFFER9_ARB
#define GL_DRAW_BUFFER9_ARB                                             0x882E
#endif //GL_DRAW_BUFFER9_ARB
#ifndef GL_DRAW_BUFFER10_ARB
#define GL_DRAW_BUFFER10_ARB                                            0x882F
#endif //GL_DRAW_BUFFER10_ARB
#ifndef GL_DRAW_BUFFER11_ARB
#define GL_DRAW_BUFFER11_ARB                                            0x8830
#endif //GL_DRAW_BUFFER11_ARB
#ifndef GL_DRAW_BUFFER12_ARB
#define GL_DRAW_BUFFER12_ARB                                            0x8831
#endif //GL_DRAW_BUFFER12_ARB
#ifndef GL_DRAW_BUFFER13_ARB
#define GL_DRAW_BUFFER13_ARB                                            0x8832
#endif //GL_DRAW_BUFFER13_ARB
#ifndef GL_DRAW_BUFFER14_ARB
#define GL_DRAW_BUFFER14_ARB                                            0x8833
#endif //GL_DRAW_BUFFER14_ARB
#ifndef GL_DRAW_BUFFER15_ARB
#define GL_DRAW_BUFFER15_ARB                                            0x8834
#endif //GL_DRAW_BUFFER15_ARB

#endif //GL_ARB_draw_buffers


typedef void (*PFNDRAWBUFFERSARBPROC_HPP)(GLsizei n,const GLenum *bufs);

static inline void DrawBuffersARB(GLsizei n,const GLenum *bufs)
{
	static PFNDRAWBUFFERSARBPROC_HPP fn=reinterpret_cast<PFNDRAWBUFFERSARBPROC_HPP>(_impl::_get_proc_address("glDrawBuffersARB","GL_ARB_draw_buffers"));
	 fn(n,bufs);
}
#ifndef GL_ARB_draw_buffers_blend

#define GL_ARB_draw_buffers_blend

#endif //GL_ARB_draw_buffers_blend


typedef void (*PFNBLENDEQUATIONIARBPROC_HPP)(GLuint buf,GLenum mode);

static inline void BlendEquationiARB(GLuint buf,GLenum mode)
{
	static PFNBLENDEQUATIONIARBPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONIARBPROC_HPP>(_impl::_get_proc_address("glBlendEquationiARB","GL_ARB_draw_buffers_blend"));
	 fn(buf,mode);
}

typedef void (*PFNBLENDEQUATIONSEPARATEIARBPROC_HPP)(GLuint buf,GLenum modeRGB,GLenum modeAlpha);

static inline void BlendEquationSeparateiARB(GLuint buf,GLenum modeRGB,GLenum modeAlpha)
{
	static PFNBLENDEQUATIONSEPARATEIARBPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONSEPARATEIARBPROC_HPP>(_impl::_get_proc_address("glBlendEquationSeparateiARB","GL_ARB_draw_buffers_blend"));
	 fn(buf,modeRGB,modeAlpha);
}

typedef void (*PFNBLENDFUNCIARBPROC_HPP)(GLuint buf,GLenum src,GLenum dst);

static inline void BlendFunciARB(GLuint buf,GLenum src,GLenum dst)
{
	static PFNBLENDFUNCIARBPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCIARBPROC_HPP>(_impl::_get_proc_address("glBlendFunciARB","GL_ARB_draw_buffers_blend"));
	 fn(buf,src,dst);
}

typedef void (*PFNBLENDFUNCSEPARATEIARBPROC_HPP)(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha);

static inline void BlendFuncSeparateiARB(GLuint buf,GLenum srcRGB,GLenum dstRGB,GLenum srcAlpha,GLenum dstAlpha)
{
	static PFNBLENDFUNCSEPARATEIARBPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEIARBPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparateiARB","GL_ARB_draw_buffers_blend"));
	 fn(buf,srcRGB,dstRGB,srcAlpha,dstAlpha);
}
#ifndef GL_ARB_draw_elements_base_vertex

#define GL_ARB_draw_elements_base_vertex

#endif //GL_ARB_draw_elements_base_vertex


typedef void (*PFNDRAWELEMENTSBASEVERTEXPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLint basevertex);

static inline void DrawElementsBaseVertex(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLint basevertex)
{
	static PFNDRAWELEMENTSBASEVERTEXPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSBASEVERTEXPROC_HPP>(_impl::_get_proc_address("glDrawElementsBaseVertex","GL_ARB_draw_elements_base_vertex"));
	 fn(mode,count,type,indices,basevertex);
}

typedef void (*PFNDRAWRANGEELEMENTSBASEVERTEXPROC_HPP)(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices,GLint basevertex);

static inline void DrawRangeElementsBaseVertex(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices,GLint basevertex)
{
	static PFNDRAWRANGEELEMENTSBASEVERTEXPROC_HPP fn=reinterpret_cast<PFNDRAWRANGEELEMENTSBASEVERTEXPROC_HPP>(_impl::_get_proc_address("glDrawRangeElementsBaseVertex","GL_ARB_draw_elements_base_vertex"));
	 fn(mode,start,end,count,type,indices,basevertex);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDBASEVERTEXPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei instancecount,GLint basevertex);

static inline void DrawElementsInstancedBaseVertex(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei instancecount,GLint basevertex)
{
	static PFNDRAWELEMENTSINSTANCEDBASEVERTEXPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDBASEVERTEXPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstancedBaseVertex","GL_ARB_draw_elements_base_vertex"));
	 fn(mode,count,type,indices,instancecount,basevertex);
}

typedef void (*PFNMULTIDRAWELEMENTSBASEVERTEXPROC_HPP)(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei drawcount,const GLint *basevertex);

static inline void MultiDrawElementsBaseVertex(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei drawcount,const GLint *basevertex)
{
	static PFNMULTIDRAWELEMENTSBASEVERTEXPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTSBASEVERTEXPROC_HPP>(_impl::_get_proc_address("glMultiDrawElementsBaseVertex","GL_ARB_draw_elements_base_vertex"));
	 fn(mode,count,type,indices,drawcount,basevertex);
}
#ifndef GL_ARB_draw_indirect

#define GL_ARB_draw_indirect
#ifndef GL_DRAW_INDIRECT_BUFFER
#define GL_DRAW_INDIRECT_BUFFER                                         0x8F3F
#endif //GL_DRAW_INDIRECT_BUFFER
#ifndef GL_DRAW_INDIRECT_BUFFER_BINDING
#define GL_DRAW_INDIRECT_BUFFER_BINDING                                 0x8F43
#endif //GL_DRAW_INDIRECT_BUFFER_BINDING

#endif //GL_ARB_draw_indirect


typedef void (*PFNDRAWARRAYSINDIRECTPROC_HPP)(GLenum mode,const GLvoid *indirect);

static inline void DrawArraysIndirect(GLenum mode,const GLvoid *indirect)
{
	static PFNDRAWARRAYSINDIRECTPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSINDIRECTPROC_HPP>(_impl::_get_proc_address("glDrawArraysIndirect","GL_ARB_draw_indirect"));
	 fn(mode,indirect);
}

typedef void (*PFNDRAWELEMENTSINDIRECTPROC_HPP)(GLenum mode,GLenum type,const GLvoid *indirect);

static inline void DrawElementsIndirect(GLenum mode,GLenum type,const GLvoid *indirect)
{
	static PFNDRAWELEMENTSINDIRECTPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINDIRECTPROC_HPP>(_impl::_get_proc_address("glDrawElementsIndirect","GL_ARB_draw_indirect"));
	 fn(mode,type,indirect);
}
#ifndef GL_ARB_draw_instanced

#define GL_ARB_draw_instanced

#endif //GL_ARB_draw_instanced


typedef void (*PFNDRAWARRAYSINSTANCEDARBPROC_HPP)(GLenum mode,GLint first,GLsizei count,GLsizei primcount);

static inline void DrawArraysInstancedARB(GLenum mode,GLint first,GLsizei count,GLsizei primcount)
{
	static PFNDRAWARRAYSINSTANCEDARBPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSINSTANCEDARBPROC_HPP>(_impl::_get_proc_address("glDrawArraysInstancedARB","GL_ARB_draw_instanced"));
	 fn(mode,first,count,primcount);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDARBPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei primcount);

static inline void DrawElementsInstancedARB(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei primcount)
{
	static PFNDRAWELEMENTSINSTANCEDARBPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDARBPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstancedARB","GL_ARB_draw_instanced"));
	 fn(mode,count,type,indices,primcount);
}
#ifndef GL_ARB_explicit_uniform_location

#define GL_ARB_explicit_uniform_location
#ifndef GL_MAX_UNIFORM_LOCATIONS
#define GL_MAX_UNIFORM_LOCATIONS                                        0x826E
#endif //GL_MAX_UNIFORM_LOCATIONS

#endif //GL_ARB_explicit_uniform_location

#ifndef GL_ARB_fragment_program

#define GL_ARB_fragment_program
#ifndef GL_VERTEX_PROGRAM_ARB
#define GL_VERTEX_PROGRAM_ARB                                           0x8620
#endif //GL_VERTEX_PROGRAM_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB
#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB                              0x8622
#endif //GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB
#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB                                 0x8623
#endif //GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB
#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB                               0x8624
#endif //GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB
#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB                                 0x8625
#endif //GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB
#ifndef GL_CURRENT_VERTEX_ATTRIB_ARB
#define GL_CURRENT_VERTEX_ATTRIB_ARB                                    0x8626
#endif //GL_CURRENT_VERTEX_ATTRIB_ARB
#ifndef GL_PROGRAM_LENGTH_ARB
#define GL_PROGRAM_LENGTH_ARB                                           0x8627
#endif //GL_PROGRAM_LENGTH_ARB
#ifndef GL_PROGRAM_STRING_ARB
#define GL_PROGRAM_STRING_ARB                                           0x8628
#endif //GL_PROGRAM_STRING_ARB
#ifndef GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB
#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB                           0x862E
#endif //GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB
#ifndef GL_MAX_PROGRAM_MATRICES_ARB
#define GL_MAX_PROGRAM_MATRICES_ARB                                     0x862F
#endif //GL_MAX_PROGRAM_MATRICES_ARB
#ifndef GL_CURRENT_MATRIX_STACK_DEPTH_ARB
#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB                               0x8640
#endif //GL_CURRENT_MATRIX_STACK_DEPTH_ARB
#ifndef GL_CURRENT_MATRIX_ARB
#define GL_CURRENT_MATRIX_ARB                                           0x8641
#endif //GL_CURRENT_MATRIX_ARB
#ifndef GL_VERTEX_PROGRAM_POINT_SIZE_ARB
#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB                                0x8642
#endif //GL_VERTEX_PROGRAM_POINT_SIZE_ARB
#ifndef GL_VERTEX_PROGRAM_TWO_SIDE_ARB
#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB                                  0x8643
#endif //GL_VERTEX_PROGRAM_TWO_SIDE_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB
#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB                              0x8645
#endif //GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB
#ifndef GL_PROGRAM_ERROR_POSITION_ARB
#define GL_PROGRAM_ERROR_POSITION_ARB                                   0x864B
#endif //GL_PROGRAM_ERROR_POSITION_ARB
#ifndef GL_PROGRAM_BINDING_ARB
#define GL_PROGRAM_BINDING_ARB                                          0x8677
#endif //GL_PROGRAM_BINDING_ARB
#ifndef GL_FRAGMENT_PROGRAM_ARB
#define GL_FRAGMENT_PROGRAM_ARB                                         0x8804
#endif //GL_FRAGMENT_PROGRAM_ARB
#ifndef GL_PROGRAM_ALU_INSTRUCTIONS_ARB
#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB                                 0x8805
#endif //GL_PROGRAM_ALU_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_TEX_INSTRUCTIONS_ARB
#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB                                 0x8806
#endif //GL_PROGRAM_TEX_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_TEX_INDIRECTIONS_ARB
#define GL_PROGRAM_TEX_INDIRECTIONS_ARB                                 0x8807
#endif //GL_PROGRAM_TEX_INDIRECTIONS_ARB
#ifndef GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB                          0x8808
#endif //GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB                          0x8809
#endif //GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB                          0x880A
#endif //GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
#ifndef GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB                             0x880B
#endif //GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB                             0x880C
#endif //GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB
#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB                             0x880D
#endif //GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB                      0x880E
#endif //GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB                      0x880F
#endif //GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB                      0x8810
#endif //GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
#ifndef GL_MAX_TEXTURE_COORDS_ARB
#define GL_MAX_TEXTURE_COORDS_ARB                                       0x8871
#endif //GL_MAX_TEXTURE_COORDS_ARB
#ifndef GL_MAX_TEXTURE_IMAGE_UNITS_ARB
#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB                                  0x8872
#endif //GL_MAX_TEXTURE_IMAGE_UNITS_ARB
#ifndef GL_PROGRAM_ERROR_STRING_ARB
#define GL_PROGRAM_ERROR_STRING_ARB                                     0x8874
#endif //GL_PROGRAM_ERROR_STRING_ARB
#ifndef GL_PROGRAM_FORMAT_ASCII_ARB
#define GL_PROGRAM_FORMAT_ASCII_ARB                                     0x8875
#endif //GL_PROGRAM_FORMAT_ASCII_ARB
#ifndef GL_PROGRAM_FORMAT_ARB
#define GL_PROGRAM_FORMAT_ARB                                           0x8876
#endif //GL_PROGRAM_FORMAT_ARB
#ifndef GL_PROGRAM_INSTRUCTIONS_ARB
#define GL_PROGRAM_INSTRUCTIONS_ARB                                     0x88A0
#endif //GL_PROGRAM_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB                                 0x88A1
#endif //GL_MAX_PROGRAM_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB
#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB                              0x88A2
#endif //GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB                          0x88A3
#endif //GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
#ifndef GL_PROGRAM_TEMPORARIES_ARB
#define GL_PROGRAM_TEMPORARIES_ARB                                      0x88A4
#endif //GL_PROGRAM_TEMPORARIES_ARB
#ifndef GL_MAX_PROGRAM_TEMPORARIES_ARB
#define GL_MAX_PROGRAM_TEMPORARIES_ARB                                  0x88A5
#endif //GL_MAX_PROGRAM_TEMPORARIES_ARB
#ifndef GL_PROGRAM_NATIVE_TEMPORARIES_ARB
#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB                               0x88A6
#endif //GL_PROGRAM_NATIVE_TEMPORARIES_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB                           0x88A7
#endif //GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
#ifndef GL_PROGRAM_PARAMETERS_ARB
#define GL_PROGRAM_PARAMETERS_ARB                                       0x88A8
#endif //GL_PROGRAM_PARAMETERS_ARB
#ifndef GL_MAX_PROGRAM_PARAMETERS_ARB
#define GL_MAX_PROGRAM_PARAMETERS_ARB                                   0x88A9
#endif //GL_MAX_PROGRAM_PARAMETERS_ARB
#ifndef GL_PROGRAM_NATIVE_PARAMETERS_ARB
#define GL_PROGRAM_NATIVE_PARAMETERS_ARB                                0x88AA
#endif //GL_PROGRAM_NATIVE_PARAMETERS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB                            0x88AB
#endif //GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
#ifndef GL_PROGRAM_ATTRIBS_ARB
#define GL_PROGRAM_ATTRIBS_ARB                                          0x88AC
#endif //GL_PROGRAM_ATTRIBS_ARB
#ifndef GL_MAX_PROGRAM_ATTRIBS_ARB
#define GL_MAX_PROGRAM_ATTRIBS_ARB                                      0x88AD
#endif //GL_MAX_PROGRAM_ATTRIBS_ARB
#ifndef GL_PROGRAM_NATIVE_ATTRIBS_ARB
#define GL_PROGRAM_NATIVE_ATTRIBS_ARB                                   0x88AE
#endif //GL_PROGRAM_NATIVE_ATTRIBS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB
#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB                               0x88AF
#endif //GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB
#ifndef GL_PROGRAM_ADDRESS_REGISTERS_ARB
#define GL_PROGRAM_ADDRESS_REGISTERS_ARB                                0x88B0
#endif //GL_PROGRAM_ADDRESS_REGISTERS_ARB
#ifndef GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB
#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB                            0x88B1
#endif //GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB
#ifndef GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB                         0x88B2
#endif //GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
#ifndef GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB                     0x88B3
#endif //GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
#ifndef GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB                             0x88B4
#endif //GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
#ifndef GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB                               0x88B5
#endif //GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
#ifndef GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB
#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB                              0x88B6
#endif //GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB
#ifndef GL_TRANSPOSE_CURRENT_MATRIX_ARB
#define GL_TRANSPOSE_CURRENT_MATRIX_ARB                                 0x88B7
#endif //GL_TRANSPOSE_CURRENT_MATRIX_ARB
#ifndef GL_MATRIX0_ARB
#define GL_MATRIX0_ARB                                                  0x88C0
#endif //GL_MATRIX0_ARB
#ifndef GL_MATRIX1_ARB
#define GL_MATRIX1_ARB                                                  0x88C1
#endif //GL_MATRIX1_ARB
#ifndef GL_MATRIX2_ARB
#define GL_MATRIX2_ARB                                                  0x88C2
#endif //GL_MATRIX2_ARB
#ifndef GL_MATRIX3_ARB
#define GL_MATRIX3_ARB                                                  0x88C3
#endif //GL_MATRIX3_ARB
#ifndef GL_MATRIX4_ARB
#define GL_MATRIX4_ARB                                                  0x88C4
#endif //GL_MATRIX4_ARB
#ifndef GL_MATRIX5_ARB
#define GL_MATRIX5_ARB                                                  0x88C5
#endif //GL_MATRIX5_ARB
#ifndef GL_MATRIX6_ARB
#define GL_MATRIX6_ARB                                                  0x88C6
#endif //GL_MATRIX6_ARB
#ifndef GL_MATRIX7_ARB
#define GL_MATRIX7_ARB                                                  0x88C7
#endif //GL_MATRIX7_ARB
#ifndef GL_MATRIX8_ARB
#define GL_MATRIX8_ARB                                                  0x88C8
#endif //GL_MATRIX8_ARB
#ifndef GL_MATRIX9_ARB
#define GL_MATRIX9_ARB                                                  0x88C9
#endif //GL_MATRIX9_ARB
#ifndef GL_MATRIX10_ARB
#define GL_MATRIX10_ARB                                                 0x88CA
#endif //GL_MATRIX10_ARB
#ifndef GL_MATRIX11_ARB
#define GL_MATRIX11_ARB                                                 0x88CB
#endif //GL_MATRIX11_ARB
#ifndef GL_MATRIX12_ARB
#define GL_MATRIX12_ARB                                                 0x88CC
#endif //GL_MATRIX12_ARB
#ifndef GL_MATRIX13_ARB
#define GL_MATRIX13_ARB                                                 0x88CD
#endif //GL_MATRIX13_ARB
#ifndef GL_MATRIX14_ARB
#define GL_MATRIX14_ARB                                                 0x88CE
#endif //GL_MATRIX14_ARB
#ifndef GL_MATRIX15_ARB
#define GL_MATRIX15_ARB                                                 0x88CF
#endif //GL_MATRIX15_ARB
#ifndef GL_MATRIX16_ARB
#define GL_MATRIX16_ARB                                                 0x88D0
#endif //GL_MATRIX16_ARB
#ifndef GL_MATRIX17_ARB
#define GL_MATRIX17_ARB                                                 0x88D1
#endif //GL_MATRIX17_ARB
#ifndef GL_MATRIX18_ARB
#define GL_MATRIX18_ARB                                                 0x88D2
#endif //GL_MATRIX18_ARB
#ifndef GL_MATRIX19_ARB
#define GL_MATRIX19_ARB                                                 0x88D3
#endif //GL_MATRIX19_ARB
#ifndef GL_MATRIX20_ARB
#define GL_MATRIX20_ARB                                                 0x88D4
#endif //GL_MATRIX20_ARB
#ifndef GL_MATRIX21_ARB
#define GL_MATRIX21_ARB                                                 0x88D5
#endif //GL_MATRIX21_ARB
#ifndef GL_MATRIX22_ARB
#define GL_MATRIX22_ARB                                                 0x88D6
#endif //GL_MATRIX22_ARB
#ifndef GL_MATRIX23_ARB
#define GL_MATRIX23_ARB                                                 0x88D7
#endif //GL_MATRIX23_ARB
#ifndef GL_MATRIX24_ARB
#define GL_MATRIX24_ARB                                                 0x88D8
#endif //GL_MATRIX24_ARB
#ifndef GL_MATRIX25_ARB
#define GL_MATRIX25_ARB                                                 0x88D9
#endif //GL_MATRIX25_ARB
#ifndef GL_MATRIX26_ARB
#define GL_MATRIX26_ARB                                                 0x88DA
#endif //GL_MATRIX26_ARB
#ifndef GL_MATRIX27_ARB
#define GL_MATRIX27_ARB                                                 0x88DB
#endif //GL_MATRIX27_ARB
#ifndef GL_MATRIX28_ARB
#define GL_MATRIX28_ARB                                                 0x88DC
#endif //GL_MATRIX28_ARB
#ifndef GL_MATRIX29_ARB
#define GL_MATRIX29_ARB                                                 0x88DD
#endif //GL_MATRIX29_ARB
#ifndef GL_MATRIX30_ARB
#define GL_MATRIX30_ARB                                                 0x88DE
#endif //GL_MATRIX30_ARB
#ifndef GL_MATRIX31_ARB
#define GL_MATRIX31_ARB                                                 0x88DF
#endif //GL_MATRIX31_ARB

#endif //GL_ARB_fragment_program

#ifndef GL_ARB_framebuffer_no_attachments

#define GL_ARB_framebuffer_no_attachments
#ifndef GL_FRAMEBUFFER_DEFAULT_WIDTH
#define GL_FRAMEBUFFER_DEFAULT_WIDTH                                    0x9310
#endif //GL_FRAMEBUFFER_DEFAULT_WIDTH
#ifndef GL_FRAMEBUFFER_DEFAULT_HEIGHT
#define GL_FRAMEBUFFER_DEFAULT_HEIGHT                                   0x9311
#endif //GL_FRAMEBUFFER_DEFAULT_HEIGHT
#ifndef GL_FRAMEBUFFER_DEFAULT_LAYERS
#define GL_FRAMEBUFFER_DEFAULT_LAYERS                                   0x9312
#endif //GL_FRAMEBUFFER_DEFAULT_LAYERS
#ifndef GL_FRAMEBUFFER_DEFAULT_SAMPLES
#define GL_FRAMEBUFFER_DEFAULT_SAMPLES                                  0x9313
#endif //GL_FRAMEBUFFER_DEFAULT_SAMPLES
#ifndef GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS
#define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS                   0x9314
#endif //GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS
#ifndef GL_MAX_FRAMEBUFFER_WIDTH
#define GL_MAX_FRAMEBUFFER_WIDTH                                        0x9315
#endif //GL_MAX_FRAMEBUFFER_WIDTH
#ifndef GL_MAX_FRAMEBUFFER_HEIGHT
#define GL_MAX_FRAMEBUFFER_HEIGHT                                       0x9316
#endif //GL_MAX_FRAMEBUFFER_HEIGHT
#ifndef GL_MAX_FRAMEBUFFER_LAYERS
#define GL_MAX_FRAMEBUFFER_LAYERS                                       0x9317
#endif //GL_MAX_FRAMEBUFFER_LAYERS
#ifndef GL_MAX_FRAMEBUFFER_SAMPLES
#define GL_MAX_FRAMEBUFFER_SAMPLES                                      0x9318
#endif //GL_MAX_FRAMEBUFFER_SAMPLES

#endif //GL_ARB_framebuffer_no_attachments


typedef void (*PFNFRAMEBUFFERPARAMETERIPROC_HPP)(GLenum target,GLenum pname,GLint param);

static inline void FramebufferParameteri(GLenum target,GLenum pname,GLint param)
{
	static PFNFRAMEBUFFERPARAMETERIPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERPARAMETERIPROC_HPP>(_impl::_get_proc_address("glFramebufferParameteri","GL_ARB_framebuffer_no_attachments"));
	 fn(target,pname,param);
}

typedef void (*PFNGETFRAMEBUFFERPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetFramebufferParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETFRAMEBUFFERPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETFRAMEBUFFERPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetFramebufferParameteriv","GL_ARB_framebuffer_no_attachments"));
	 fn(target,pname,params);
}

typedef void (*PFNNAMEDFRAMEBUFFERPARAMETERIEXTPROC_HPP)(GLuint framebuffer,GLenum pname,GLint param);

static inline void NamedFramebufferParameteriEXT(GLuint framebuffer,GLenum pname,GLint param)
{
	static PFNNAMEDFRAMEBUFFERPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferParameteriEXT","GL_ARB_framebuffer_no_attachments"));
	 fn(framebuffer,pname,param);
}

typedef void (*PFNGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC_HPP)(GLuint framebuffer,GLenum pname,GLint *params);

static inline void GetNamedFramebufferParameterivEXT(GLuint framebuffer,GLenum pname,GLint *params)
{
	static PFNGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDFRAMEBUFFERPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedFramebufferParameterivEXT","GL_ARB_framebuffer_no_attachments"));
	 fn(framebuffer,pname,params);
}
#ifndef GL_ARB_framebuffer_object

#define GL_ARB_framebuffer_object
#ifndef GL_INVALID_FRAMEBUFFER_OPERATION
#define GL_INVALID_FRAMEBUFFER_OPERATION                                0x0506
#endif //GL_INVALID_FRAMEBUFFER_OPERATION
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE                           0x8D56
#endif //GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
#ifndef GL_MAX_SAMPLES
#define GL_MAX_SAMPLES                                                  0x8D57
#endif //GL_MAX_SAMPLES

#endif //GL_ARB_framebuffer_object


typedef GLboolean (*PFNISRENDERBUFFERPROC_HPP)(GLuint renderbuffer);

static inline GLboolean IsRenderbuffer(GLuint renderbuffer)
{
	static PFNISRENDERBUFFERPROC_HPP fn=reinterpret_cast<PFNISRENDERBUFFERPROC_HPP>(_impl::_get_proc_address("glIsRenderbuffer","GL_ARB_framebuffer_object"));
	return fn(renderbuffer);
}

typedef void (*PFNBINDRENDERBUFFERPROC_HPP)(GLenum target,GLuint renderbuffer);

static inline void BindRenderbuffer(GLenum target,GLuint renderbuffer)
{
	static PFNBINDRENDERBUFFERPROC_HPP fn=reinterpret_cast<PFNBINDRENDERBUFFERPROC_HPP>(_impl::_get_proc_address("glBindRenderbuffer","GL_ARB_framebuffer_object"));
	 fn(target,renderbuffer);
}

typedef void (*PFNDELETERENDERBUFFERSPROC_HPP)(GLsizei n,const GLuint *renderbuffers);

static inline void DeleteRenderbuffers(GLsizei n,const GLuint *renderbuffers)
{
	static PFNDELETERENDERBUFFERSPROC_HPP fn=reinterpret_cast<PFNDELETERENDERBUFFERSPROC_HPP>(_impl::_get_proc_address("glDeleteRenderbuffers","GL_ARB_framebuffer_object"));
	 fn(n,renderbuffers);
}

typedef void (*PFNGENRENDERBUFFERSPROC_HPP)(GLsizei n,GLuint *renderbuffers);

static inline void GenRenderbuffers(GLsizei n,GLuint *renderbuffers)
{
	static PFNGENRENDERBUFFERSPROC_HPP fn=reinterpret_cast<PFNGENRENDERBUFFERSPROC_HPP>(_impl::_get_proc_address("glGenRenderbuffers","GL_ARB_framebuffer_object"));
	 fn(n,renderbuffers);
}

typedef void (*PFNRENDERBUFFERSTORAGEPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height);

static inline void RenderbufferStorage(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNRENDERBUFFERSTORAGEPROC_HPP fn=reinterpret_cast<PFNRENDERBUFFERSTORAGEPROC_HPP>(_impl::_get_proc_address("glRenderbufferStorage","GL_ARB_framebuffer_object"));
	 fn(target,internalformat,width,height);
}

typedef void (*PFNGETRENDERBUFFERPARAMETERIVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetRenderbufferParameteriv(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETRENDERBUFFERPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETRENDERBUFFERPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetRenderbufferParameteriv","GL_ARB_framebuffer_object"));
	 fn(target,pname,params);
}

typedef GLboolean (*PFNISFRAMEBUFFERPROC_HPP)(GLuint framebuffer);

static inline GLboolean IsFramebuffer(GLuint framebuffer)
{
	static PFNISFRAMEBUFFERPROC_HPP fn=reinterpret_cast<PFNISFRAMEBUFFERPROC_HPP>(_impl::_get_proc_address("glIsFramebuffer","GL_ARB_framebuffer_object"));
	return fn(framebuffer);
}

typedef void (*PFNBINDFRAMEBUFFERPROC_HPP)(GLenum target,GLuint framebuffer);

static inline void BindFramebuffer(GLenum target,GLuint framebuffer)
{
	static PFNBINDFRAMEBUFFERPROC_HPP fn=reinterpret_cast<PFNBINDFRAMEBUFFERPROC_HPP>(_impl::_get_proc_address("glBindFramebuffer","GL_ARB_framebuffer_object"));
	 fn(target,framebuffer);
}

typedef void (*PFNDELETEFRAMEBUFFERSPROC_HPP)(GLsizei n,const GLuint *framebuffers);

static inline void DeleteFramebuffers(GLsizei n,const GLuint *framebuffers)
{
	static PFNDELETEFRAMEBUFFERSPROC_HPP fn=reinterpret_cast<PFNDELETEFRAMEBUFFERSPROC_HPP>(_impl::_get_proc_address("glDeleteFramebuffers","GL_ARB_framebuffer_object"));
	 fn(n,framebuffers);
}

typedef void (*PFNGENFRAMEBUFFERSPROC_HPP)(GLsizei n,GLuint *framebuffers);

static inline void GenFramebuffers(GLsizei n,GLuint *framebuffers)
{
	static PFNGENFRAMEBUFFERSPROC_HPP fn=reinterpret_cast<PFNGENFRAMEBUFFERSPROC_HPP>(_impl::_get_proc_address("glGenFramebuffers","GL_ARB_framebuffer_object"));
	 fn(n,framebuffers);
}

typedef GLenum (*PFNCHECKFRAMEBUFFERSTATUSPROC_HPP)(GLenum target);

static inline GLenum CheckFramebufferStatus(GLenum target)
{
	static PFNCHECKFRAMEBUFFERSTATUSPROC_HPP fn=reinterpret_cast<PFNCHECKFRAMEBUFFERSTATUSPROC_HPP>(_impl::_get_proc_address("glCheckFramebufferStatus","GL_ARB_framebuffer_object"));
	return fn(target);
}

typedef void (*PFNFRAMEBUFFERTEXTURE1DPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void FramebufferTexture1D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTURE1DPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE1DPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture1D","GL_ARB_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURE2DPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void FramebufferTexture2D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTURE2DPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE2DPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture2D","GL_ARB_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURE3DPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);

static inline void FramebufferTexture3D(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)
{
	static PFNFRAMEBUFFERTEXTURE3DPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE3DPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture3D","GL_ARB_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level,zoffset);
}

typedef void (*PFNFRAMEBUFFERRENDERBUFFERPROC_HPP)(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);

static inline void FramebufferRenderbuffer(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)
{
	static PFNFRAMEBUFFERRENDERBUFFERPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERRENDERBUFFERPROC_HPP>(_impl::_get_proc_address("glFramebufferRenderbuffer","GL_ARB_framebuffer_object"));
	 fn(target,attachment,renderbuffertarget,renderbuffer);
}

typedef void (*PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC_HPP)(GLenum target,GLenum attachment,GLenum pname,GLint *params);

static inline void GetFramebufferAttachmentParameteriv(GLenum target,GLenum attachment,GLenum pname,GLint *params)
{
	static PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetFramebufferAttachmentParameteriv","GL_ARB_framebuffer_object"));
	 fn(target,attachment,pname,params);
}

typedef void (*PFNGENERATEMIPMAPPROC_HPP)(GLenum target);

static inline void GenerateMipmap(GLenum target)
{
	static PFNGENERATEMIPMAPPROC_HPP fn=reinterpret_cast<PFNGENERATEMIPMAPPROC_HPP>(_impl::_get_proc_address("glGenerateMipmap","GL_ARB_framebuffer_object"));
	 fn(target);
}

typedef void (*PFNBLITFRAMEBUFFERPROC_HPP)(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter);

static inline void BlitFramebuffer(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)
{
	static PFNBLITFRAMEBUFFERPROC_HPP fn=reinterpret_cast<PFNBLITFRAMEBUFFERPROC_HPP>(_impl::_get_proc_address("glBlitFramebuffer","GL_ARB_framebuffer_object"));
	 fn(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
}

typedef void (*PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC_HPP)(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);

static inline void RenderbufferStorageMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC_HPP fn=reinterpret_cast<PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC_HPP>(_impl::_get_proc_address("glRenderbufferStorageMultisample","GL_ARB_framebuffer_object"));
	 fn(target,samples,internalformat,width,height);
}

typedef void (*PFNFRAMEBUFFERTEXTURELAYERPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);

static inline void FramebufferTextureLayer(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)
{
	static PFNFRAMEBUFFERTEXTURELAYERPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURELAYERPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureLayer","GL_ARB_framebuffer_object"));
	 fn(target,attachment,texture,level,layer);
}
#ifndef GL_ARB_framebuffer_sRGB

#define GL_ARB_framebuffer_sRGB
#ifndef GL_FRAMEBUFFER_SRGB
#define GL_FRAMEBUFFER_SRGB                                             0x8DB9
#endif //GL_FRAMEBUFFER_SRGB

#endif //GL_ARB_framebuffer_sRGB

#ifndef GL_ARB_geometry_shader4

#define GL_ARB_geometry_shader4
#ifndef GL_LINES_ADJACENCY_ARB
#define GL_LINES_ADJACENCY_ARB                                          0x000A
#endif //GL_LINES_ADJACENCY_ARB
#ifndef GL_LINE_STRIP_ADJACENCY_ARB
#define GL_LINE_STRIP_ADJACENCY_ARB                                     0x000B
#endif //GL_LINE_STRIP_ADJACENCY_ARB
#ifndef GL_TRIANGLES_ADJACENCY_ARB
#define GL_TRIANGLES_ADJACENCY_ARB                                      0x000C
#endif //GL_TRIANGLES_ADJACENCY_ARB
#ifndef GL_TRIANGLE_STRIP_ADJACENCY_ARB
#define GL_TRIANGLE_STRIP_ADJACENCY_ARB                                 0x000D
#endif //GL_TRIANGLE_STRIP_ADJACENCY_ARB
#ifndef GL_PROGRAM_POINT_SIZE_ARB
#define GL_PROGRAM_POINT_SIZE_ARB                                       0x8642
#endif //GL_PROGRAM_POINT_SIZE_ARB
#ifndef GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB
#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB                         0x8C29
#endif //GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB
#ifndef GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB
#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB                           0x8DA7
#endif //GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB
#ifndef GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB                     0x8DA8
#endif //GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB
#ifndef GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB                       0x8DA9
#endif //GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB
#ifndef GL_GEOMETRY_SHADER_ARB
#define GL_GEOMETRY_SHADER_ARB                                          0x8DD9
#endif //GL_GEOMETRY_SHADER_ARB
#ifndef GL_GEOMETRY_VERTICES_OUT_ARB
#define GL_GEOMETRY_VERTICES_OUT_ARB                                    0x8DDA
#endif //GL_GEOMETRY_VERTICES_OUT_ARB
#ifndef GL_GEOMETRY_INPUT_TYPE_ARB
#define GL_GEOMETRY_INPUT_TYPE_ARB                                      0x8DDB
#endif //GL_GEOMETRY_INPUT_TYPE_ARB
#ifndef GL_GEOMETRY_OUTPUT_TYPE_ARB
#define GL_GEOMETRY_OUTPUT_TYPE_ARB                                     0x8DDC
#endif //GL_GEOMETRY_OUTPUT_TYPE_ARB
#ifndef GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB
#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB                          0x8DDD
#endif //GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB
#ifndef GL_MAX_VERTEX_VARYING_COMPONENTS_ARB
#define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB                            0x8DDE
#endif //GL_MAX_VERTEX_VARYING_COMPONENTS_ARB
#ifndef GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB
#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB                          0x8DDF
#endif //GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB
#ifndef GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB
#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB                             0x8DE0
#endif //GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB
#ifndef GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB
#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB                     0x8DE1
#endif //GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB

#endif //GL_ARB_geometry_shader4


typedef void (*PFNPROGRAMPARAMETERIARBPROC_HPP)(GLuint program,GLenum pname,GLint value);

static inline void ProgramParameteriARB(GLuint program,GLenum pname,GLint value)
{
	static PFNPROGRAMPARAMETERIARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETERIARBPROC_HPP>(_impl::_get_proc_address("glProgramParameteriARB","GL_ARB_geometry_shader4"));
	 fn(program,pname,value);
}

typedef void (*PFNFRAMEBUFFERTEXTUREARBPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level);

static inline void FramebufferTextureARB(GLenum target,GLenum attachment,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTUREARBPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTUREARBPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureARB","GL_ARB_geometry_shader4"));
	 fn(target,attachment,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURELAYERARBPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);

static inline void FramebufferTextureLayerARB(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)
{
	static PFNFRAMEBUFFERTEXTURELAYERARBPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURELAYERARBPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureLayerARB","GL_ARB_geometry_shader4"));
	 fn(target,attachment,texture,level,layer);
}

typedef void (*PFNFRAMEBUFFERTEXTUREFACEARBPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face);

static inline void FramebufferTextureFaceARB(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face)
{
	static PFNFRAMEBUFFERTEXTUREFACEARBPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTUREFACEARBPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureFaceARB","GL_ARB_geometry_shader4"));
	 fn(target,attachment,texture,level,face);
}
#ifndef GL_ARB_get_program_binary

#define GL_ARB_get_program_binary
#ifndef GL_PROGRAM_BINARY_RETRIEVABLE_HINT
#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT                              0x8257
#endif //GL_PROGRAM_BINARY_RETRIEVABLE_HINT
#ifndef GL_PROGRAM_BINARY_LENGTH
#define GL_PROGRAM_BINARY_LENGTH                                        0x8741
#endif //GL_PROGRAM_BINARY_LENGTH
#ifndef GL_NUM_PROGRAM_BINARY_FORMATS
#define GL_NUM_PROGRAM_BINARY_FORMATS                                   0x87FE
#endif //GL_NUM_PROGRAM_BINARY_FORMATS
#ifndef GL_PROGRAM_BINARY_FORMATS
#define GL_PROGRAM_BINARY_FORMATS                                       0x87FF
#endif //GL_PROGRAM_BINARY_FORMATS

#endif //GL_ARB_get_program_binary


typedef void (*PFNGETPROGRAMBINARYPROC_HPP)(GLuint program,GLsizei bufSize,GLsizei *length,GLenum *binaryFormat,GLvoid *binary);

static inline void GetProgramBinary(GLuint program,GLsizei bufSize,GLsizei *length,GLenum *binaryFormat,GLvoid *binary)
{
	static PFNGETPROGRAMBINARYPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMBINARYPROC_HPP>(_impl::_get_proc_address("glGetProgramBinary","GL_ARB_get_program_binary"));
	 fn(program,bufSize,length,binaryFormat,binary);
}

typedef void (*PFNPROGRAMBINARYPROC_HPP)(GLuint program,GLenum binaryFormat,const GLvoid *binary,GLsizei length);

static inline void ProgramBinary(GLuint program,GLenum binaryFormat,const GLvoid *binary,GLsizei length)
{
	static PFNPROGRAMBINARYPROC_HPP fn=reinterpret_cast<PFNPROGRAMBINARYPROC_HPP>(_impl::_get_proc_address("glProgramBinary","GL_ARB_get_program_binary"));
	 fn(program,binaryFormat,binary,length);
}

typedef void (*PFNPROGRAMPARAMETERIPROC_HPP)(GLuint program,GLenum pname,GLint value);

static inline void ProgramParameteri(GLuint program,GLenum pname,GLint value)
{
	static PFNPROGRAMPARAMETERIPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETERIPROC_HPP>(_impl::_get_proc_address("glProgramParameteri","GL_ARB_get_program_binary"));
	 fn(program,pname,value);
}
#ifndef GL_ARB_gpu_shader5

#define GL_ARB_gpu_shader5
#ifndef GL_GEOMETRY_SHADER_INVOCATIONS
#define GL_GEOMETRY_SHADER_INVOCATIONS                                  0x887F
#endif //GL_GEOMETRY_SHADER_INVOCATIONS
#ifndef GL_MAX_GEOMETRY_SHADER_INVOCATIONS
#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS                              0x8E5A
#endif //GL_MAX_GEOMETRY_SHADER_INVOCATIONS
#ifndef GL_MIN_FRAGMENT_INTERPOLATION_OFFSET
#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET                            0x8E5B
#endif //GL_MIN_FRAGMENT_INTERPOLATION_OFFSET
#ifndef GL_MAX_FRAGMENT_INTERPOLATION_OFFSET
#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET                            0x8E5C
#endif //GL_MAX_FRAGMENT_INTERPOLATION_OFFSET
#ifndef GL_FRAGMENT_INTERPOLATION_OFFSET_BITS
#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS                           0x8E5D
#endif //GL_FRAGMENT_INTERPOLATION_OFFSET_BITS
#ifndef GL_MAX_VERTEX_STREAMS
#define GL_MAX_VERTEX_STREAMS                                           0x8E71
#endif //GL_MAX_VERTEX_STREAMS

#endif //GL_ARB_gpu_shader5

#ifndef GL_ARB_gpu_shader_fp64

#define GL_ARB_gpu_shader_fp64
#ifndef GL_DOUBLE_MAT2
#define GL_DOUBLE_MAT2                                                  0x8F46
#endif //GL_DOUBLE_MAT2
#ifndef GL_DOUBLE_MAT3
#define GL_DOUBLE_MAT3                                                  0x8F47
#endif //GL_DOUBLE_MAT3
#ifndef GL_DOUBLE_MAT4
#define GL_DOUBLE_MAT4                                                  0x8F48
#endif //GL_DOUBLE_MAT4
#ifndef GL_DOUBLE_MAT2x3
#define GL_DOUBLE_MAT2x3                                                0x8F49
#endif //GL_DOUBLE_MAT2x3
#ifndef GL_DOUBLE_MAT2x4
#define GL_DOUBLE_MAT2x4                                                0x8F4A
#endif //GL_DOUBLE_MAT2x4
#ifndef GL_DOUBLE_MAT3x2
#define GL_DOUBLE_MAT3x2                                                0x8F4B
#endif //GL_DOUBLE_MAT3x2
#ifndef GL_DOUBLE_MAT3x4
#define GL_DOUBLE_MAT3x4                                                0x8F4C
#endif //GL_DOUBLE_MAT3x4
#ifndef GL_DOUBLE_MAT4x2
#define GL_DOUBLE_MAT4x2                                                0x8F4D
#endif //GL_DOUBLE_MAT4x2
#ifndef GL_DOUBLE_MAT4x3
#define GL_DOUBLE_MAT4x3                                                0x8F4E
#endif //GL_DOUBLE_MAT4x3
#ifndef GL_DOUBLE_VEC2
#define GL_DOUBLE_VEC2                                                  0x8FFC
#endif //GL_DOUBLE_VEC2
#ifndef GL_DOUBLE_VEC3
#define GL_DOUBLE_VEC3                                                  0x8FFD
#endif //GL_DOUBLE_VEC3
#ifndef GL_DOUBLE_VEC4
#define GL_DOUBLE_VEC4                                                  0x8FFE
#endif //GL_DOUBLE_VEC4

#endif //GL_ARB_gpu_shader_fp64


typedef void (*PFNUNIFORM1DPROC_HPP)(GLint location,GLdouble x);

static inline void Uniform1d(GLint location,GLdouble x)
{
	static PFNUNIFORM1DPROC_HPP fn=reinterpret_cast<PFNUNIFORM1DPROC_HPP>(_impl::_get_proc_address("glUniform1d","GL_ARB_gpu_shader_fp64"));
	 fn(location,x);
}

typedef void (*PFNUNIFORM2DPROC_HPP)(GLint location,GLdouble x,GLdouble y);

static inline void Uniform2d(GLint location,GLdouble x,GLdouble y)
{
	static PFNUNIFORM2DPROC_HPP fn=reinterpret_cast<PFNUNIFORM2DPROC_HPP>(_impl::_get_proc_address("glUniform2d","GL_ARB_gpu_shader_fp64"));
	 fn(location,x,y);
}

typedef void (*PFNUNIFORM3DPROC_HPP)(GLint location,GLdouble x,GLdouble y,GLdouble z);

static inline void Uniform3d(GLint location,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNUNIFORM3DPROC_HPP fn=reinterpret_cast<PFNUNIFORM3DPROC_HPP>(_impl::_get_proc_address("glUniform3d","GL_ARB_gpu_shader_fp64"));
	 fn(location,x,y,z);
}

typedef void (*PFNUNIFORM4DPROC_HPP)(GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void Uniform4d(GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNUNIFORM4DPROC_HPP fn=reinterpret_cast<PFNUNIFORM4DPROC_HPP>(_impl::_get_proc_address("glUniform4d","GL_ARB_gpu_shader_fp64"));
	 fn(location,x,y,z,w);
}

typedef void (*PFNUNIFORM1DVPROC_HPP)(GLint location,GLsizei count,const GLdouble *value);

static inline void Uniform1dv(GLint location,GLsizei count,const GLdouble *value)
{
	static PFNUNIFORM1DVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1DVPROC_HPP>(_impl::_get_proc_address("glUniform1dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2DVPROC_HPP)(GLint location,GLsizei count,const GLdouble *value);

static inline void Uniform2dv(GLint location,GLsizei count,const GLdouble *value)
{
	static PFNUNIFORM2DVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2DVPROC_HPP>(_impl::_get_proc_address("glUniform2dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3DVPROC_HPP)(GLint location,GLsizei count,const GLdouble *value);

static inline void Uniform3dv(GLint location,GLsizei count,const GLdouble *value)
{
	static PFNUNIFORM3DVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3DVPROC_HPP>(_impl::_get_proc_address("glUniform3dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4DVPROC_HPP)(GLint location,GLsizei count,const GLdouble *value);

static inline void Uniform4dv(GLint location,GLsizei count,const GLdouble *value)
{
	static PFNUNIFORM4DVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4DVPROC_HPP>(_impl::_get_proc_address("glUniform4dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORMMATRIX2DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX2DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX3DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX4DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX2X3DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix2x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX2X3DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2X3DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2x3dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX2X4DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix2x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX2X4DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2X4DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2x4dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3X2DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix3x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX3X2DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3X2DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3x2dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3X4DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix3x4dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX3X4DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3X4DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3x4dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4X2DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix4x2dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX4X2DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4X2DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4x2dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4X3DVPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void UniformMatrix4x3dv(GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNUNIFORMMATRIX4X3DVPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4X3DVPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4x3dv","GL_ARB_gpu_shader_fp64"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNGETUNIFORMDVPROC_HPP)(GLuint program,GLint location,GLdouble *params);

static inline void GetUniformdv(GLuint program,GLint location,GLdouble *params)
{
	static PFNGETUNIFORMDVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMDVPROC_HPP>(_impl::_get_proc_address("glGetUniformdv","GL_ARB_gpu_shader_fp64"));
	 fn(program,location,params);
}
#ifndef GL_ARB_half_float_pixel

#define GL_ARB_half_float_pixel
#ifndef GL_HALF_FLOAT_ARB
#define GL_HALF_FLOAT_ARB                                               0x140B
#endif //GL_HALF_FLOAT_ARB

#endif //GL_ARB_half_float_pixel

#ifndef GL_ARB_half_float_vertex

#define GL_ARB_half_float_vertex
#ifndef GL_HALF_FLOAT
#define GL_HALF_FLOAT                                                   0x140B
#endif //GL_HALF_FLOAT

#endif //GL_ARB_half_float_vertex

#ifndef GL_ARB_instanced_arrays

#define GL_ARB_instanced_arrays
#ifndef GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB                              0x88FE
#endif //GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB

#endif //GL_ARB_instanced_arrays


typedef void (*PFNVERTEXATTRIBDIVISORARBPROC_HPP)(GLuint index,GLuint divisor);

static inline void VertexAttribDivisorARB(GLuint index,GLuint divisor)
{
	static PFNVERTEXATTRIBDIVISORARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBDIVISORARBPROC_HPP>(_impl::_get_proc_address("glVertexAttribDivisorARB","GL_ARB_instanced_arrays"));
	 fn(index,divisor);
}
#ifndef GL_ARB_internalformat_query

#define GL_ARB_internalformat_query
#ifndef GL_NUM_SAMPLE_COUNTS
#define GL_NUM_SAMPLE_COUNTS                                            0x9380
#endif //GL_NUM_SAMPLE_COUNTS

#endif //GL_ARB_internalformat_query


typedef void (*PFNGETINTERNALFORMATIVPROC_HPP)(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint *params);

static inline void GetInternalformativ(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint *params)
{
	static PFNGETINTERNALFORMATIVPROC_HPP fn=reinterpret_cast<PFNGETINTERNALFORMATIVPROC_HPP>(_impl::_get_proc_address("glGetInternalformativ","GL_ARB_internalformat_query"));
	 fn(target,internalformat,pname,bufSize,params);
}
#ifndef GL_ARB_internalformat_query2

#define GL_ARB_internalformat_query2
#ifndef GL_INTERNALFORMAT_SUPPORTED
#define GL_INTERNALFORMAT_SUPPORTED                                     0x826F
#endif //GL_INTERNALFORMAT_SUPPORTED
#ifndef GL_INTERNALFORMAT_PREFERRED
#define GL_INTERNALFORMAT_PREFERRED                                     0x8270
#endif //GL_INTERNALFORMAT_PREFERRED
#ifndef GL_INTERNALFORMAT_RED_SIZE
#define GL_INTERNALFORMAT_RED_SIZE                                      0x8271
#endif //GL_INTERNALFORMAT_RED_SIZE
#ifndef GL_INTERNALFORMAT_GREEN_SIZE
#define GL_INTERNALFORMAT_GREEN_SIZE                                    0x8272
#endif //GL_INTERNALFORMAT_GREEN_SIZE
#ifndef GL_INTERNALFORMAT_BLUE_SIZE
#define GL_INTERNALFORMAT_BLUE_SIZE                                     0x8273
#endif //GL_INTERNALFORMAT_BLUE_SIZE
#ifndef GL_INTERNALFORMAT_ALPHA_SIZE
#define GL_INTERNALFORMAT_ALPHA_SIZE                                    0x8274
#endif //GL_INTERNALFORMAT_ALPHA_SIZE
#ifndef GL_INTERNALFORMAT_DEPTH_SIZE
#define GL_INTERNALFORMAT_DEPTH_SIZE                                    0x8275
#endif //GL_INTERNALFORMAT_DEPTH_SIZE
#ifndef GL_INTERNALFORMAT_STENCIL_SIZE
#define GL_INTERNALFORMAT_STENCIL_SIZE                                  0x8276
#endif //GL_INTERNALFORMAT_STENCIL_SIZE
#ifndef GL_INTERNALFORMAT_SHARED_SIZE
#define GL_INTERNALFORMAT_SHARED_SIZE                                   0x8277
#endif //GL_INTERNALFORMAT_SHARED_SIZE
#ifndef GL_INTERNALFORMAT_RED_TYPE
#define GL_INTERNALFORMAT_RED_TYPE                                      0x8278
#endif //GL_INTERNALFORMAT_RED_TYPE
#ifndef GL_INTERNALFORMAT_GREEN_TYPE
#define GL_INTERNALFORMAT_GREEN_TYPE                                    0x8279
#endif //GL_INTERNALFORMAT_GREEN_TYPE
#ifndef GL_INTERNALFORMAT_BLUE_TYPE
#define GL_INTERNALFORMAT_BLUE_TYPE                                     0x827A
#endif //GL_INTERNALFORMAT_BLUE_TYPE
#ifndef GL_INTERNALFORMAT_ALPHA_TYPE
#define GL_INTERNALFORMAT_ALPHA_TYPE                                    0x827B
#endif //GL_INTERNALFORMAT_ALPHA_TYPE
#ifndef GL_INTERNALFORMAT_DEPTH_TYPE
#define GL_INTERNALFORMAT_DEPTH_TYPE                                    0x827C
#endif //GL_INTERNALFORMAT_DEPTH_TYPE
#ifndef GL_INTERNALFORMAT_STENCIL_TYPE
#define GL_INTERNALFORMAT_STENCIL_TYPE                                  0x827D
#endif //GL_INTERNALFORMAT_STENCIL_TYPE
#ifndef GL_MAX_WIDTH
#define GL_MAX_WIDTH                                                    0x827E
#endif //GL_MAX_WIDTH
#ifndef GL_MAX_HEIGHT
#define GL_MAX_HEIGHT                                                   0x827F
#endif //GL_MAX_HEIGHT
#ifndef GL_MAX_DEPTH
#define GL_MAX_DEPTH                                                    0x8280
#endif //GL_MAX_DEPTH
#ifndef GL_MAX_LAYERS
#define GL_MAX_LAYERS                                                   0x8281
#endif //GL_MAX_LAYERS
#ifndef GL_MAX_COMBINED_DIMENSIONS
#define GL_MAX_COMBINED_DIMENSIONS                                      0x8282
#endif //GL_MAX_COMBINED_DIMENSIONS
#ifndef GL_COLOR_COMPONENTS
#define GL_COLOR_COMPONENTS                                             0x8283
#endif //GL_COLOR_COMPONENTS
#ifndef GL_DEPTH_COMPONENTS
#define GL_DEPTH_COMPONENTS                                             0x8284
#endif //GL_DEPTH_COMPONENTS
#ifndef GL_STENCIL_COMPONENTS
#define GL_STENCIL_COMPONENTS                                           0x8285
#endif //GL_STENCIL_COMPONENTS
#ifndef GL_COLOR_RENDERABLE
#define GL_COLOR_RENDERABLE                                             0x8286
#endif //GL_COLOR_RENDERABLE
#ifndef GL_DEPTH_RENDERABLE
#define GL_DEPTH_RENDERABLE                                             0x8287
#endif //GL_DEPTH_RENDERABLE
#ifndef GL_STENCIL_RENDERABLE
#define GL_STENCIL_RENDERABLE                                           0x8288
#endif //GL_STENCIL_RENDERABLE
#ifndef GL_FRAMEBUFFER_RENDERABLE
#define GL_FRAMEBUFFER_RENDERABLE                                       0x8289
#endif //GL_FRAMEBUFFER_RENDERABLE
#ifndef GL_FRAMEBUFFER_RENDERABLE_LAYERED
#define GL_FRAMEBUFFER_RENDERABLE_LAYERED                               0x828A
#endif //GL_FRAMEBUFFER_RENDERABLE_LAYERED
#ifndef GL_FRAMEBUFFER_BLEND
#define GL_FRAMEBUFFER_BLEND                                            0x828B
#endif //GL_FRAMEBUFFER_BLEND
#ifndef GL_READ_PIXELS
#define GL_READ_PIXELS                                                  0x828C
#endif //GL_READ_PIXELS
#ifndef GL_READ_PIXELS_FORMAT
#define GL_READ_PIXELS_FORMAT                                           0x828D
#endif //GL_READ_PIXELS_FORMAT
#ifndef GL_READ_PIXELS_TYPE
#define GL_READ_PIXELS_TYPE                                             0x828E
#endif //GL_READ_PIXELS_TYPE
#ifndef GL_TEXTURE_IMAGE_FORMAT
#define GL_TEXTURE_IMAGE_FORMAT                                         0x828F
#endif //GL_TEXTURE_IMAGE_FORMAT
#ifndef GL_TEXTURE_IMAGE_TYPE
#define GL_TEXTURE_IMAGE_TYPE                                           0x8290
#endif //GL_TEXTURE_IMAGE_TYPE
#ifndef GL_GET_TEXTURE_IMAGE_FORMAT
#define GL_GET_TEXTURE_IMAGE_FORMAT                                     0x8291
#endif //GL_GET_TEXTURE_IMAGE_FORMAT
#ifndef GL_GET_TEXTURE_IMAGE_TYPE
#define GL_GET_TEXTURE_IMAGE_TYPE                                       0x8292
#endif //GL_GET_TEXTURE_IMAGE_TYPE
#ifndef GL_MIPMAP
#define GL_MIPMAP                                                       0x8293
#endif //GL_MIPMAP
#ifndef GL_MANUAL_GENERATE_MIPMAP
#define GL_MANUAL_GENERATE_MIPMAP                                       0x8294
#endif //GL_MANUAL_GENERATE_MIPMAP
#ifndef GL_AUTO_GENERATE_MIPMAP
#define GL_AUTO_GENERATE_MIPMAP                                         0x8295
#endif //GL_AUTO_GENERATE_MIPMAP
#ifndef GL_COLOR_ENCODING
#define GL_COLOR_ENCODING                                               0x8296
#endif //GL_COLOR_ENCODING
#ifndef GL_SRGB_READ
#define GL_SRGB_READ                                                    0x8297
#endif //GL_SRGB_READ
#ifndef GL_SRGB_WRITE
#define GL_SRGB_WRITE                                                   0x8298
#endif //GL_SRGB_WRITE
#ifndef GL_SRGB_DECODE_ARB
#define GL_SRGB_DECODE_ARB                                              0x8299
#endif //GL_SRGB_DECODE_ARB
#ifndef GL_FILTER
#define GL_FILTER                                                       0x829A
#endif //GL_FILTER
#ifndef GL_VERTEX_TEXTURE
#define GL_VERTEX_TEXTURE                                               0x829B
#endif //GL_VERTEX_TEXTURE
#ifndef GL_TESS_CONTROL_TEXTURE
#define GL_TESS_CONTROL_TEXTURE                                         0x829C
#endif //GL_TESS_CONTROL_TEXTURE
#ifndef GL_TESS_EVALUATION_TEXTURE
#define GL_TESS_EVALUATION_TEXTURE                                      0x829D
#endif //GL_TESS_EVALUATION_TEXTURE
#ifndef GL_GEOMETRY_TEXTURE
#define GL_GEOMETRY_TEXTURE                                             0x829E
#endif //GL_GEOMETRY_TEXTURE
#ifndef GL_FRAGMENT_TEXTURE
#define GL_FRAGMENT_TEXTURE                                             0x829F
#endif //GL_FRAGMENT_TEXTURE
#ifndef GL_COMPUTE_TEXTURE
#define GL_COMPUTE_TEXTURE                                              0x82A0
#endif //GL_COMPUTE_TEXTURE
#ifndef GL_TEXTURE_SHADOW
#define GL_TEXTURE_SHADOW                                               0x82A1
#endif //GL_TEXTURE_SHADOW
#ifndef GL_TEXTURE_GATHER
#define GL_TEXTURE_GATHER                                               0x82A2
#endif //GL_TEXTURE_GATHER
#ifndef GL_TEXTURE_GATHER_SHADOW
#define GL_TEXTURE_GATHER_SHADOW                                        0x82A3
#endif //GL_TEXTURE_GATHER_SHADOW
#ifndef GL_SHADER_IMAGE_LOAD
#define GL_SHADER_IMAGE_LOAD                                            0x82A4
#endif //GL_SHADER_IMAGE_LOAD
#ifndef GL_SHADER_IMAGE_STORE
#define GL_SHADER_IMAGE_STORE                                           0x82A5
#endif //GL_SHADER_IMAGE_STORE
#ifndef GL_SHADER_IMAGE_ATOMIC
#define GL_SHADER_IMAGE_ATOMIC                                          0x82A6
#endif //GL_SHADER_IMAGE_ATOMIC
#ifndef GL_IMAGE_TEXEL_SIZE
#define GL_IMAGE_TEXEL_SIZE                                             0x82A7
#endif //GL_IMAGE_TEXEL_SIZE
#ifndef GL_IMAGE_COMPATIBILITY_CLASS
#define GL_IMAGE_COMPATIBILITY_CLASS                                    0x82A8
#endif //GL_IMAGE_COMPATIBILITY_CLASS
#ifndef GL_IMAGE_PIXEL_FORMAT
#define GL_IMAGE_PIXEL_FORMAT                                           0x82A9
#endif //GL_IMAGE_PIXEL_FORMAT
#ifndef GL_IMAGE_PIXEL_TYPE
#define GL_IMAGE_PIXEL_TYPE                                             0x82AA
#endif //GL_IMAGE_PIXEL_TYPE
#ifndef GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST                          0x82AC
#endif //GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
#ifndef GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST                        0x82AD
#endif //GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
#ifndef GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE                         0x82AE
#endif //GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
#ifndef GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE                       0x82AF
#endif //GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
#ifndef GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
#define GL_TEXTURE_COMPRESSED_BLOCK_WIDTH                               0x82B1
#endif //GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
#ifndef GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT
#define GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT                              0x82B2
#endif //GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT
#ifndef GL_TEXTURE_COMPRESSED_BLOCK_SIZE
#define GL_TEXTURE_COMPRESSED_BLOCK_SIZE                                0x82B3
#endif //GL_TEXTURE_COMPRESSED_BLOCK_SIZE
#ifndef GL_CLEAR_BUFFER
#define GL_CLEAR_BUFFER                                                 0x82B4
#endif //GL_CLEAR_BUFFER
#ifndef GL_TEXTURE_VIEW
#define GL_TEXTURE_VIEW                                                 0x82B5
#endif //GL_TEXTURE_VIEW
#ifndef GL_VIEW_COMPATIBILITY_CLASS
#define GL_VIEW_COMPATIBILITY_CLASS                                     0x82B6
#endif //GL_VIEW_COMPATIBILITY_CLASS
#ifndef GL_FULL_SUPPORT
#define GL_FULL_SUPPORT                                                 0x82B7
#endif //GL_FULL_SUPPORT
#ifndef GL_CAVEAT_SUPPORT
#define GL_CAVEAT_SUPPORT                                               0x82B8
#endif //GL_CAVEAT_SUPPORT
#ifndef GL_IMAGE_CLASS_4_X_32
#define GL_IMAGE_CLASS_4_X_32                                           0x82B9
#endif //GL_IMAGE_CLASS_4_X_32
#ifndef GL_IMAGE_CLASS_2_X_32
#define GL_IMAGE_CLASS_2_X_32                                           0x82BA
#endif //GL_IMAGE_CLASS_2_X_32
#ifndef GL_IMAGE_CLASS_1_X_32
#define GL_IMAGE_CLASS_1_X_32                                           0x82BB
#endif //GL_IMAGE_CLASS_1_X_32
#ifndef GL_IMAGE_CLASS_4_X_16
#define GL_IMAGE_CLASS_4_X_16                                           0x82BC
#endif //GL_IMAGE_CLASS_4_X_16
#ifndef GL_IMAGE_CLASS_2_X_16
#define GL_IMAGE_CLASS_2_X_16                                           0x82BD
#endif //GL_IMAGE_CLASS_2_X_16
#ifndef GL_IMAGE_CLASS_1_X_16
#define GL_IMAGE_CLASS_1_X_16                                           0x82BE
#endif //GL_IMAGE_CLASS_1_X_16
#ifndef GL_IMAGE_CLASS_4_X_8
#define GL_IMAGE_CLASS_4_X_8                                            0x82BF
#endif //GL_IMAGE_CLASS_4_X_8
#ifndef GL_IMAGE_CLASS_2_X_8
#define GL_IMAGE_CLASS_2_X_8                                            0x82C0
#endif //GL_IMAGE_CLASS_2_X_8
#ifndef GL_IMAGE_CLASS_1_X_8
#define GL_IMAGE_CLASS_1_X_8                                            0x82C1
#endif //GL_IMAGE_CLASS_1_X_8
#ifndef GL_IMAGE_CLASS_11_11_10
#define GL_IMAGE_CLASS_11_11_10                                         0x82C2
#endif //GL_IMAGE_CLASS_11_11_10
#ifndef GL_IMAGE_CLASS_10_10_10_2
#define GL_IMAGE_CLASS_10_10_10_2                                       0x82C3
#endif //GL_IMAGE_CLASS_10_10_10_2
#ifndef GL_VIEW_CLASS_128_BITS
#define GL_VIEW_CLASS_128_BITS                                          0x82C4
#endif //GL_VIEW_CLASS_128_BITS
#ifndef GL_VIEW_CLASS_96_BITS
#define GL_VIEW_CLASS_96_BITS                                           0x82C5
#endif //GL_VIEW_CLASS_96_BITS
#ifndef GL_VIEW_CLASS_64_BITS
#define GL_VIEW_CLASS_64_BITS                                           0x82C6
#endif //GL_VIEW_CLASS_64_BITS
#ifndef GL_VIEW_CLASS_48_BITS
#define GL_VIEW_CLASS_48_BITS                                           0x82C7
#endif //GL_VIEW_CLASS_48_BITS
#ifndef GL_VIEW_CLASS_32_BITS
#define GL_VIEW_CLASS_32_BITS                                           0x82C8
#endif //GL_VIEW_CLASS_32_BITS
#ifndef GL_VIEW_CLASS_24_BITS
#define GL_VIEW_CLASS_24_BITS                                           0x82C9
#endif //GL_VIEW_CLASS_24_BITS
#ifndef GL_VIEW_CLASS_16_BITS
#define GL_VIEW_CLASS_16_BITS                                           0x82CA
#endif //GL_VIEW_CLASS_16_BITS
#ifndef GL_VIEW_CLASS_8_BITS
#define GL_VIEW_CLASS_8_BITS                                            0x82CB
#endif //GL_VIEW_CLASS_8_BITS
#ifndef GL_VIEW_CLASS_S3TC_DXT1_RGB
#define GL_VIEW_CLASS_S3TC_DXT1_RGB                                     0x82CC
#endif //GL_VIEW_CLASS_S3TC_DXT1_RGB
#ifndef GL_VIEW_CLASS_S3TC_DXT1_RGBA
#define GL_VIEW_CLASS_S3TC_DXT1_RGBA                                    0x82CD
#endif //GL_VIEW_CLASS_S3TC_DXT1_RGBA
#ifndef GL_VIEW_CLASS_S3TC_DXT3_RGBA
#define GL_VIEW_CLASS_S3TC_DXT3_RGBA                                    0x82CE
#endif //GL_VIEW_CLASS_S3TC_DXT3_RGBA
#ifndef GL_VIEW_CLASS_S3TC_DXT5_RGBA
#define GL_VIEW_CLASS_S3TC_DXT5_RGBA                                    0x82CF
#endif //GL_VIEW_CLASS_S3TC_DXT5_RGBA
#ifndef GL_VIEW_CLASS_RGTC1_RED
#define GL_VIEW_CLASS_RGTC1_RED                                         0x82D0
#endif //GL_VIEW_CLASS_RGTC1_RED
#ifndef GL_VIEW_CLASS_RGTC2_RG
#define GL_VIEW_CLASS_RGTC2_RG                                          0x82D1
#endif //GL_VIEW_CLASS_RGTC2_RG
#ifndef GL_VIEW_CLASS_BPTC_UNORM
#define GL_VIEW_CLASS_BPTC_UNORM                                        0x82D2
#endif //GL_VIEW_CLASS_BPTC_UNORM
#ifndef GL_VIEW_CLASS_BPTC_FLOAT
#define GL_VIEW_CLASS_BPTC_FLOAT                                        0x82D3
#endif //GL_VIEW_CLASS_BPTC_FLOAT

#endif //GL_ARB_internalformat_query2


typedef void (*PFNGETINTERNALFORMATI64VPROC_HPP)(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint64 *params);

static inline void GetInternalformati64v(GLenum target,GLenum internalformat,GLenum pname,GLsizei bufSize,GLint64 *params)
{
	static PFNGETINTERNALFORMATI64VPROC_HPP fn=reinterpret_cast<PFNGETINTERNALFORMATI64VPROC_HPP>(_impl::_get_proc_address("glGetInternalformati64v","GL_ARB_internalformat_query2"));
	 fn(target,internalformat,pname,bufSize,params);
}
#ifndef GL_ARB_invalidate_subdata

#define GL_ARB_invalidate_subdata

#endif //GL_ARB_invalidate_subdata


typedef void (*PFNINVALIDATETEXSUBIMAGEPROC_HPP)(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth);

static inline void InvalidateTexSubImage(GLuint texture,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth)
{
	static PFNINVALIDATETEXSUBIMAGEPROC_HPP fn=reinterpret_cast<PFNINVALIDATETEXSUBIMAGEPROC_HPP>(_impl::_get_proc_address("glInvalidateTexSubImage","GL_ARB_invalidate_subdata"));
	 fn(texture,level,xoffset,yoffset,zoffset,width,height,depth);
}

typedef void (*PFNINVALIDATETEXIMAGEPROC_HPP)(GLuint texture,GLint level);

static inline void InvalidateTexImage(GLuint texture,GLint level)
{
	static PFNINVALIDATETEXIMAGEPROC_HPP fn=reinterpret_cast<PFNINVALIDATETEXIMAGEPROC_HPP>(_impl::_get_proc_address("glInvalidateTexImage","GL_ARB_invalidate_subdata"));
	 fn(texture,level);
}

typedef void (*PFNINVALIDATEBUFFERSUBDATAPROC_HPP)(GLuint buffer,GLintptr offset,GLsizeiptr length);

static inline void InvalidateBufferSubData(GLuint buffer,GLintptr offset,GLsizeiptr length)
{
	static PFNINVALIDATEBUFFERSUBDATAPROC_HPP fn=reinterpret_cast<PFNINVALIDATEBUFFERSUBDATAPROC_HPP>(_impl::_get_proc_address("glInvalidateBufferSubData","GL_ARB_invalidate_subdata"));
	 fn(buffer,offset,length);
}

typedef void (*PFNINVALIDATEBUFFERDATAPROC_HPP)(GLuint buffer);

static inline void InvalidateBufferData(GLuint buffer)
{
	static PFNINVALIDATEBUFFERDATAPROC_HPP fn=reinterpret_cast<PFNINVALIDATEBUFFERDATAPROC_HPP>(_impl::_get_proc_address("glInvalidateBufferData","GL_ARB_invalidate_subdata"));
	 fn(buffer);
}

typedef void (*PFNINVALIDATEFRAMEBUFFERPROC_HPP)(GLenum target,GLsizei numAttachments,const GLenum *attachments);

static inline void InvalidateFramebuffer(GLenum target,GLsizei numAttachments,const GLenum *attachments)
{
	static PFNINVALIDATEFRAMEBUFFERPROC_HPP fn=reinterpret_cast<PFNINVALIDATEFRAMEBUFFERPROC_HPP>(_impl::_get_proc_address("glInvalidateFramebuffer","GL_ARB_invalidate_subdata"));
	 fn(target,numAttachments,attachments);
}

typedef void (*PFNINVALIDATESUBFRAMEBUFFERPROC_HPP)(GLenum target,GLsizei numAttachments,const GLenum *attachments,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void InvalidateSubFramebuffer(GLenum target,GLsizei numAttachments,const GLenum *attachments,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNINVALIDATESUBFRAMEBUFFERPROC_HPP fn=reinterpret_cast<PFNINVALIDATESUBFRAMEBUFFERPROC_HPP>(_impl::_get_proc_address("glInvalidateSubFramebuffer","GL_ARB_invalidate_subdata"));
	 fn(target,numAttachments,attachments,x,y,width,height);
}
#ifndef GL_ARB_map_buffer_alignment

#define GL_ARB_map_buffer_alignment
#ifndef GL_MIN_MAP_BUFFER_ALIGNMENT
#define GL_MIN_MAP_BUFFER_ALIGNMENT                                     0x90BC
#endif //GL_MIN_MAP_BUFFER_ALIGNMENT

#endif //GL_ARB_map_buffer_alignment

#ifndef GL_ARB_map_buffer_range

#define GL_ARB_map_buffer_range

#endif //GL_ARB_map_buffer_range


typedef GLvoid* (*PFNMAPBUFFERRANGEPROC_HPP)(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access);

static inline GLvoid* MapBufferRange(GLenum target,GLintptr offset,GLsizeiptr length,GLbitfield access)
{
	static PFNMAPBUFFERRANGEPROC_HPP fn=reinterpret_cast<PFNMAPBUFFERRANGEPROC_HPP>(_impl::_get_proc_address("glMapBufferRange","GL_ARB_map_buffer_range"));
	return fn(target,offset,length,access);
}

typedef void (*PFNFLUSHMAPPEDBUFFERRANGEPROC_HPP)(GLenum target,GLintptr offset,GLsizeiptr length);

static inline void FlushMappedBufferRange(GLenum target,GLintptr offset,GLsizeiptr length)
{
	static PFNFLUSHMAPPEDBUFFERRANGEPROC_HPP fn=reinterpret_cast<PFNFLUSHMAPPEDBUFFERRANGEPROC_HPP>(_impl::_get_proc_address("glFlushMappedBufferRange","GL_ARB_map_buffer_range"));
	 fn(target,offset,length);
}
#ifndef GL_ARB_matrix_palette

#define GL_ARB_matrix_palette
#ifndef GL_MATRIX_PALETTE_ARB
#define GL_MATRIX_PALETTE_ARB                                           0x8840
#endif //GL_MATRIX_PALETTE_ARB
#ifndef GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB
#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB                           0x8841
#endif //GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB
#ifndef GL_MAX_PALETTE_MATRICES_ARB
#define GL_MAX_PALETTE_MATRICES_ARB                                     0x8842
#endif //GL_MAX_PALETTE_MATRICES_ARB
#ifndef GL_CURRENT_PALETTE_MATRIX_ARB
#define GL_CURRENT_PALETTE_MATRIX_ARB                                   0x8843
#endif //GL_CURRENT_PALETTE_MATRIX_ARB
#ifndef GL_MATRIX_INDEX_ARRAY_ARB
#define GL_MATRIX_INDEX_ARRAY_ARB                                       0x8844
#endif //GL_MATRIX_INDEX_ARRAY_ARB
#ifndef GL_CURRENT_MATRIX_INDEX_ARB
#define GL_CURRENT_MATRIX_INDEX_ARB                                     0x8845
#endif //GL_CURRENT_MATRIX_INDEX_ARB
#ifndef GL_MATRIX_INDEX_ARRAY_SIZE_ARB
#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB                                  0x8846
#endif //GL_MATRIX_INDEX_ARRAY_SIZE_ARB
#ifndef GL_MATRIX_INDEX_ARRAY_TYPE_ARB
#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB                                  0x8847
#endif //GL_MATRIX_INDEX_ARRAY_TYPE_ARB
#ifndef GL_MATRIX_INDEX_ARRAY_STRIDE_ARB
#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB                                0x8848
#endif //GL_MATRIX_INDEX_ARRAY_STRIDE_ARB
#ifndef GL_MATRIX_INDEX_ARRAY_POINTER_ARB
#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB                               0x8849
#endif //GL_MATRIX_INDEX_ARRAY_POINTER_ARB

#endif //GL_ARB_matrix_palette


typedef void (*PFNCURRENTPALETTEMATRIXARBPROC_HPP)(GLint index);

static inline void CurrentPaletteMatrixARB(GLint index)
{
	static PFNCURRENTPALETTEMATRIXARBPROC_HPP fn=reinterpret_cast<PFNCURRENTPALETTEMATRIXARBPROC_HPP>(_impl::_get_proc_address("glCurrentPaletteMatrixARB","GL_ARB_matrix_palette"));
	 fn(index);
}

typedef void (*PFNMATRIXINDEXUBVARBPROC_HPP)(GLint size,const GLubyte *indices);

static inline void MatrixIndexubvARB(GLint size,const GLubyte *indices)
{
	static PFNMATRIXINDEXUBVARBPROC_HPP fn=reinterpret_cast<PFNMATRIXINDEXUBVARBPROC_HPP>(_impl::_get_proc_address("glMatrixIndexubvARB","GL_ARB_matrix_palette"));
	 fn(size,indices);
}

typedef void (*PFNMATRIXINDEXUSVARBPROC_HPP)(GLint size,const GLushort *indices);

static inline void MatrixIndexusvARB(GLint size,const GLushort *indices)
{
	static PFNMATRIXINDEXUSVARBPROC_HPP fn=reinterpret_cast<PFNMATRIXINDEXUSVARBPROC_HPP>(_impl::_get_proc_address("glMatrixIndexusvARB","GL_ARB_matrix_palette"));
	 fn(size,indices);
}

typedef void (*PFNMATRIXINDEXUIVARBPROC_HPP)(GLint size,const GLuint *indices);

static inline void MatrixIndexuivARB(GLint size,const GLuint *indices)
{
	static PFNMATRIXINDEXUIVARBPROC_HPP fn=reinterpret_cast<PFNMATRIXINDEXUIVARBPROC_HPP>(_impl::_get_proc_address("glMatrixIndexuivARB","GL_ARB_matrix_palette"));
	 fn(size,indices);
}

typedef void (*PFNMATRIXINDEXPOINTERARBPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void MatrixIndexPointerARB(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNMATRIXINDEXPOINTERARBPROC_HPP fn=reinterpret_cast<PFNMATRIXINDEXPOINTERARBPROC_HPP>(_impl::_get_proc_address("glMatrixIndexPointerARB","GL_ARB_matrix_palette"));
	 fn(size,type,stride,pointer);
}
#ifndef GL_ARB_multi_draw_indirect

#define GL_ARB_multi_draw_indirect

#endif //GL_ARB_multi_draw_indirect


typedef void (*PFNMULTIDRAWARRAYSINDIRECTPROC_HPP)(GLenum mode,const void *indirect,GLsizei drawcount,GLsizei stride);

static inline void MultiDrawArraysIndirect(GLenum mode,const void *indirect,GLsizei drawcount,GLsizei stride)
{
	static PFNMULTIDRAWARRAYSINDIRECTPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWARRAYSINDIRECTPROC_HPP>(_impl::_get_proc_address("glMultiDrawArraysIndirect","GL_ARB_multi_draw_indirect"));
	 fn(mode,indirect,drawcount,stride);
}

typedef void (*PFNMULTIDRAWELEMENTSINDIRECTPROC_HPP)(GLenum mode,GLenum type,const void *indirect,GLsizei drawcount,GLsizei stride);

static inline void MultiDrawElementsIndirect(GLenum mode,GLenum type,const void *indirect,GLsizei drawcount,GLsizei stride)
{
	static PFNMULTIDRAWELEMENTSINDIRECTPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTSINDIRECTPROC_HPP>(_impl::_get_proc_address("glMultiDrawElementsIndirect","GL_ARB_multi_draw_indirect"));
	 fn(mode,type,indirect,drawcount,stride);
}
#ifndef GL_ARB_multisample

#define GL_ARB_multisample
#ifndef GL_MULTISAMPLE_BIT_ARB
#define GL_MULTISAMPLE_BIT_ARB                                          0x20000000
#endif //GL_MULTISAMPLE_BIT_ARB
#ifndef GL_MULTISAMPLE_ARB
#define GL_MULTISAMPLE_ARB                                              0x809D
#endif //GL_MULTISAMPLE_ARB
#ifndef GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB                                 0x809E
#endif //GL_SAMPLE_ALPHA_TO_COVERAGE_ARB
#ifndef GL_SAMPLE_ALPHA_TO_ONE_ARB
#define GL_SAMPLE_ALPHA_TO_ONE_ARB                                      0x809F
#endif //GL_SAMPLE_ALPHA_TO_ONE_ARB
#ifndef GL_SAMPLE_COVERAGE_ARB
#define GL_SAMPLE_COVERAGE_ARB                                          0x80A0
#endif //GL_SAMPLE_COVERAGE_ARB
#ifndef GL_SAMPLE_BUFFERS_ARB
#define GL_SAMPLE_BUFFERS_ARB                                           0x80A8
#endif //GL_SAMPLE_BUFFERS_ARB
#ifndef GL_SAMPLES_ARB
#define GL_SAMPLES_ARB                                                  0x80A9
#endif //GL_SAMPLES_ARB
#ifndef GL_SAMPLE_COVERAGE_VALUE_ARB
#define GL_SAMPLE_COVERAGE_VALUE_ARB                                    0x80AA
#endif //GL_SAMPLE_COVERAGE_VALUE_ARB
#ifndef GL_SAMPLE_COVERAGE_INVERT_ARB
#define GL_SAMPLE_COVERAGE_INVERT_ARB                                   0x80AB
#endif //GL_SAMPLE_COVERAGE_INVERT_ARB

#endif //GL_ARB_multisample


typedef void (*PFNSAMPLECOVERAGEARBPROC_HPP)(GLfloat value,GLboolean invert);

static inline void SampleCoverageARB(GLfloat value,GLboolean invert)
{
	static PFNSAMPLECOVERAGEARBPROC_HPP fn=reinterpret_cast<PFNSAMPLECOVERAGEARBPROC_HPP>(_impl::_get_proc_address("glSampleCoverageARB","GL_ARB_multisample"));
	 fn(value,invert);
}
#ifndef GL_ARB_multitexture

#define GL_ARB_multitexture
#ifndef GL_TEXTURE0_ARB
#define GL_TEXTURE0_ARB                                                 0x84C0
#endif //GL_TEXTURE0_ARB
#ifndef GL_TEXTURE1_ARB
#define GL_TEXTURE1_ARB                                                 0x84C1
#endif //GL_TEXTURE1_ARB
#ifndef GL_TEXTURE2_ARB
#define GL_TEXTURE2_ARB                                                 0x84C2
#endif //GL_TEXTURE2_ARB
#ifndef GL_TEXTURE3_ARB
#define GL_TEXTURE3_ARB                                                 0x84C3
#endif //GL_TEXTURE3_ARB
#ifndef GL_TEXTURE4_ARB
#define GL_TEXTURE4_ARB                                                 0x84C4
#endif //GL_TEXTURE4_ARB
#ifndef GL_TEXTURE5_ARB
#define GL_TEXTURE5_ARB                                                 0x84C5
#endif //GL_TEXTURE5_ARB
#ifndef GL_TEXTURE6_ARB
#define GL_TEXTURE6_ARB                                                 0x84C6
#endif //GL_TEXTURE6_ARB
#ifndef GL_TEXTURE7_ARB
#define GL_TEXTURE7_ARB                                                 0x84C7
#endif //GL_TEXTURE7_ARB
#ifndef GL_TEXTURE8_ARB
#define GL_TEXTURE8_ARB                                                 0x84C8
#endif //GL_TEXTURE8_ARB
#ifndef GL_TEXTURE9_ARB
#define GL_TEXTURE9_ARB                                                 0x84C9
#endif //GL_TEXTURE9_ARB
#ifndef GL_TEXTURE10_ARB
#define GL_TEXTURE10_ARB                                                0x84CA
#endif //GL_TEXTURE10_ARB
#ifndef GL_TEXTURE11_ARB
#define GL_TEXTURE11_ARB                                                0x84CB
#endif //GL_TEXTURE11_ARB
#ifndef GL_TEXTURE12_ARB
#define GL_TEXTURE12_ARB                                                0x84CC
#endif //GL_TEXTURE12_ARB
#ifndef GL_TEXTURE13_ARB
#define GL_TEXTURE13_ARB                                                0x84CD
#endif //GL_TEXTURE13_ARB
#ifndef GL_TEXTURE14_ARB
#define GL_TEXTURE14_ARB                                                0x84CE
#endif //GL_TEXTURE14_ARB
#ifndef GL_TEXTURE15_ARB
#define GL_TEXTURE15_ARB                                                0x84CF
#endif //GL_TEXTURE15_ARB
#ifndef GL_TEXTURE16_ARB
#define GL_TEXTURE16_ARB                                                0x84D0
#endif //GL_TEXTURE16_ARB
#ifndef GL_TEXTURE17_ARB
#define GL_TEXTURE17_ARB                                                0x84D1
#endif //GL_TEXTURE17_ARB
#ifndef GL_TEXTURE18_ARB
#define GL_TEXTURE18_ARB                                                0x84D2
#endif //GL_TEXTURE18_ARB
#ifndef GL_TEXTURE19_ARB
#define GL_TEXTURE19_ARB                                                0x84D3
#endif //GL_TEXTURE19_ARB
#ifndef GL_TEXTURE20_ARB
#define GL_TEXTURE20_ARB                                                0x84D4
#endif //GL_TEXTURE20_ARB
#ifndef GL_TEXTURE21_ARB
#define GL_TEXTURE21_ARB                                                0x84D5
#endif //GL_TEXTURE21_ARB
#ifndef GL_TEXTURE22_ARB
#define GL_TEXTURE22_ARB                                                0x84D6
#endif //GL_TEXTURE22_ARB
#ifndef GL_TEXTURE23_ARB
#define GL_TEXTURE23_ARB                                                0x84D7
#endif //GL_TEXTURE23_ARB
#ifndef GL_TEXTURE24_ARB
#define GL_TEXTURE24_ARB                                                0x84D8
#endif //GL_TEXTURE24_ARB
#ifndef GL_TEXTURE25_ARB
#define GL_TEXTURE25_ARB                                                0x84D9
#endif //GL_TEXTURE25_ARB
#ifndef GL_TEXTURE26_ARB
#define GL_TEXTURE26_ARB                                                0x84DA
#endif //GL_TEXTURE26_ARB
#ifndef GL_TEXTURE27_ARB
#define GL_TEXTURE27_ARB                                                0x84DB
#endif //GL_TEXTURE27_ARB
#ifndef GL_TEXTURE28_ARB
#define GL_TEXTURE28_ARB                                                0x84DC
#endif //GL_TEXTURE28_ARB
#ifndef GL_TEXTURE29_ARB
#define GL_TEXTURE29_ARB                                                0x84DD
#endif //GL_TEXTURE29_ARB
#ifndef GL_TEXTURE30_ARB
#define GL_TEXTURE30_ARB                                                0x84DE
#endif //GL_TEXTURE30_ARB
#ifndef GL_TEXTURE31_ARB
#define GL_TEXTURE31_ARB                                                0x84DF
#endif //GL_TEXTURE31_ARB
#ifndef GL_ACTIVE_TEXTURE_ARB
#define GL_ACTIVE_TEXTURE_ARB                                           0x84E0
#endif //GL_ACTIVE_TEXTURE_ARB
#ifndef GL_CLIENT_ACTIVE_TEXTURE_ARB
#define GL_CLIENT_ACTIVE_TEXTURE_ARB                                    0x84E1
#endif //GL_CLIENT_ACTIVE_TEXTURE_ARB
#ifndef GL_MAX_TEXTURE_UNITS_ARB
#define GL_MAX_TEXTURE_UNITS_ARB                                        0x84E2
#endif //GL_MAX_TEXTURE_UNITS_ARB

#endif //GL_ARB_multitexture


typedef void (*PFNACTIVETEXTUREARBPROC_HPP)(GLenum texture);

static inline void ActiveTextureARB(GLenum texture)
{
	static PFNACTIVETEXTUREARBPROC_HPP fn=reinterpret_cast<PFNACTIVETEXTUREARBPROC_HPP>(_impl::_get_proc_address("glActiveTextureARB","GL_ARB_multitexture"));
	 fn(texture);
}

typedef void (*PFNCLIENTACTIVETEXTUREARBPROC_HPP)(GLenum texture);

static inline void ClientActiveTextureARB(GLenum texture)
{
	static PFNCLIENTACTIVETEXTUREARBPROC_HPP fn=reinterpret_cast<PFNCLIENTACTIVETEXTUREARBPROC_HPP>(_impl::_get_proc_address("glClientActiveTextureARB","GL_ARB_multitexture"));
	 fn(texture);
}

typedef void (*PFNMULTITEXCOORD1DARBPROC_HPP)(GLenum target,GLdouble s);

static inline void MultiTexCoord1dARB(GLenum target,GLdouble s)
{
	static PFNMULTITEXCOORD1DARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1DARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1dARB","GL_ARB_multitexture"));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1DVARBPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord1dvARB(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD1DVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1DVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1dvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1FARBPROC_HPP)(GLenum target,GLfloat s);

static inline void MultiTexCoord1fARB(GLenum target,GLfloat s)
{
	static PFNMULTITEXCOORD1FARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1FARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1fARB","GL_ARB_multitexture"));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1FVARBPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord1fvARB(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD1FVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1FVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1fvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1IARBPROC_HPP)(GLenum target,GLint s);

static inline void MultiTexCoord1iARB(GLenum target,GLint s)
{
	static PFNMULTITEXCOORD1IARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1IARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1iARB","GL_ARB_multitexture"));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1IVARBPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord1ivARB(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD1IVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1IVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1ivARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD1SARBPROC_HPP)(GLenum target,GLshort s);

static inline void MultiTexCoord1sARB(GLenum target,GLshort s)
{
	static PFNMULTITEXCOORD1SARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1SARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1sARB","GL_ARB_multitexture"));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1SVARBPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord1svARB(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD1SVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1SVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1svARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2DARBPROC_HPP)(GLenum target,GLdouble s,GLdouble t);

static inline void MultiTexCoord2dARB(GLenum target,GLdouble s,GLdouble t)
{
	static PFNMULTITEXCOORD2DARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2DARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2dARB","GL_ARB_multitexture"));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2DVARBPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord2dvARB(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD2DVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2DVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2dvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2FARBPROC_HPP)(GLenum target,GLfloat s,GLfloat t);

static inline void MultiTexCoord2fARB(GLenum target,GLfloat s,GLfloat t)
{
	static PFNMULTITEXCOORD2FARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2FARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2fARB","GL_ARB_multitexture"));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2FVARBPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord2fvARB(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD2FVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2FVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2fvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2IARBPROC_HPP)(GLenum target,GLint s,GLint t);

static inline void MultiTexCoord2iARB(GLenum target,GLint s,GLint t)
{
	static PFNMULTITEXCOORD2IARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2IARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2iARB","GL_ARB_multitexture"));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2IVARBPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord2ivARB(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD2IVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2IVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2ivARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2SARBPROC_HPP)(GLenum target,GLshort s,GLshort t);

static inline void MultiTexCoord2sARB(GLenum target,GLshort s,GLshort t)
{
	static PFNMULTITEXCOORD2SARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2SARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2sARB","GL_ARB_multitexture"));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2SVARBPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord2svARB(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD2SVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2SVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2svARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3DARBPROC_HPP)(GLenum target,GLdouble s,GLdouble t,GLdouble r);

static inline void MultiTexCoord3dARB(GLenum target,GLdouble s,GLdouble t,GLdouble r)
{
	static PFNMULTITEXCOORD3DARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3DARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3dARB","GL_ARB_multitexture"));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3DVARBPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord3dvARB(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD3DVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3DVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3dvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3FARBPROC_HPP)(GLenum target,GLfloat s,GLfloat t,GLfloat r);

static inline void MultiTexCoord3fARB(GLenum target,GLfloat s,GLfloat t,GLfloat r)
{
	static PFNMULTITEXCOORD3FARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3FARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3fARB","GL_ARB_multitexture"));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3FVARBPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord3fvARB(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD3FVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3FVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3fvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3IARBPROC_HPP)(GLenum target,GLint s,GLint t,GLint r);

static inline void MultiTexCoord3iARB(GLenum target,GLint s,GLint t,GLint r)
{
	static PFNMULTITEXCOORD3IARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3IARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3iARB","GL_ARB_multitexture"));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3IVARBPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord3ivARB(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD3IVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3IVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3ivARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3SARBPROC_HPP)(GLenum target,GLshort s,GLshort t,GLshort r);

static inline void MultiTexCoord3sARB(GLenum target,GLshort s,GLshort t,GLshort r)
{
	static PFNMULTITEXCOORD3SARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3SARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3sARB","GL_ARB_multitexture"));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3SVARBPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord3svARB(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD3SVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3SVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3svARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4DARBPROC_HPP)(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q);

static inline void MultiTexCoord4dARB(GLenum target,GLdouble s,GLdouble t,GLdouble r,GLdouble q)
{
	static PFNMULTITEXCOORD4DARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4DARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4dARB","GL_ARB_multitexture"));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4DVARBPROC_HPP)(GLenum target,const GLdouble *v);

static inline void MultiTexCoord4dvARB(GLenum target,const GLdouble *v)
{
	static PFNMULTITEXCOORD4DVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4DVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4dvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4FARBPROC_HPP)(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q);

static inline void MultiTexCoord4fARB(GLenum target,GLfloat s,GLfloat t,GLfloat r,GLfloat q)
{
	static PFNMULTITEXCOORD4FARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4FARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4fARB","GL_ARB_multitexture"));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4FVARBPROC_HPP)(GLenum target,const GLfloat *v);

static inline void MultiTexCoord4fvARB(GLenum target,const GLfloat *v)
{
	static PFNMULTITEXCOORD4FVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4FVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4fvARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4IARBPROC_HPP)(GLenum target,GLint s,GLint t,GLint r,GLint q);

static inline void MultiTexCoord4iARB(GLenum target,GLint s,GLint t,GLint r,GLint q)
{
	static PFNMULTITEXCOORD4IARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4IARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4iARB","GL_ARB_multitexture"));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4IVARBPROC_HPP)(GLenum target,const GLint *v);

static inline void MultiTexCoord4ivARB(GLenum target,const GLint *v)
{
	static PFNMULTITEXCOORD4IVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4IVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4ivARB","GL_ARB_multitexture"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4SARBPROC_HPP)(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q);

static inline void MultiTexCoord4sARB(GLenum target,GLshort s,GLshort t,GLshort r,GLshort q)
{
	static PFNMULTITEXCOORD4SARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4SARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4sARB","GL_ARB_multitexture"));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4SVARBPROC_HPP)(GLenum target,const GLshort *v);

static inline void MultiTexCoord4svARB(GLenum target,const GLshort *v)
{
	static PFNMULTITEXCOORD4SVARBPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4SVARBPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4svARB","GL_ARB_multitexture"));
	 fn(target,v);
}
#ifndef GL_ARB_occlusion_query

#define GL_ARB_occlusion_query
#ifndef GL_QUERY_COUNTER_BITS_ARB
#define GL_QUERY_COUNTER_BITS_ARB                                       0x8864
#endif //GL_QUERY_COUNTER_BITS_ARB
#ifndef GL_CURRENT_QUERY_ARB
#define GL_CURRENT_QUERY_ARB                                            0x8865
#endif //GL_CURRENT_QUERY_ARB
#ifndef GL_QUERY_RESULT_ARB
#define GL_QUERY_RESULT_ARB                                             0x8866
#endif //GL_QUERY_RESULT_ARB
#ifndef GL_QUERY_RESULT_AVAILABLE_ARB
#define GL_QUERY_RESULT_AVAILABLE_ARB                                   0x8867
#endif //GL_QUERY_RESULT_AVAILABLE_ARB
#ifndef GL_SAMPLES_PASSED_ARB
#define GL_SAMPLES_PASSED_ARB                                           0x8914
#endif //GL_SAMPLES_PASSED_ARB

#endif //GL_ARB_occlusion_query


typedef void (*PFNGENQUERIESARBPROC_HPP)(GLsizei n,GLuint *ids);

static inline void GenQueriesARB(GLsizei n,GLuint *ids)
{
	static PFNGENQUERIESARBPROC_HPP fn=reinterpret_cast<PFNGENQUERIESARBPROC_HPP>(_impl::_get_proc_address("glGenQueriesARB","GL_ARB_occlusion_query"));
	 fn(n,ids);
}

typedef void (*PFNDELETEQUERIESARBPROC_HPP)(GLsizei n,const GLuint *ids);

static inline void DeleteQueriesARB(GLsizei n,const GLuint *ids)
{
	static PFNDELETEQUERIESARBPROC_HPP fn=reinterpret_cast<PFNDELETEQUERIESARBPROC_HPP>(_impl::_get_proc_address("glDeleteQueriesARB","GL_ARB_occlusion_query"));
	 fn(n,ids);
}

typedef GLboolean (*PFNISQUERYARBPROC_HPP)(GLuint id);

static inline GLboolean IsQueryARB(GLuint id)
{
	static PFNISQUERYARBPROC_HPP fn=reinterpret_cast<PFNISQUERYARBPROC_HPP>(_impl::_get_proc_address("glIsQueryARB","GL_ARB_occlusion_query"));
	return fn(id);
}

typedef void (*PFNBEGINQUERYARBPROC_HPP)(GLenum target,GLuint id);

static inline void BeginQueryARB(GLenum target,GLuint id)
{
	static PFNBEGINQUERYARBPROC_HPP fn=reinterpret_cast<PFNBEGINQUERYARBPROC_HPP>(_impl::_get_proc_address("glBeginQueryARB","GL_ARB_occlusion_query"));
	 fn(target,id);
}

typedef void (*PFNENDQUERYARBPROC_HPP)(GLenum target);

static inline void EndQueryARB(GLenum target)
{
	static PFNENDQUERYARBPROC_HPP fn=reinterpret_cast<PFNENDQUERYARBPROC_HPP>(_impl::_get_proc_address("glEndQueryARB","GL_ARB_occlusion_query"));
	 fn(target);
}

typedef void (*PFNGETQUERYIVARBPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetQueryivARB(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETQUERYIVARBPROC_HPP fn=reinterpret_cast<PFNGETQUERYIVARBPROC_HPP>(_impl::_get_proc_address("glGetQueryivARB","GL_ARB_occlusion_query"));
	 fn(target,pname,params);
}

typedef void (*PFNGETQUERYOBJECTIVARBPROC_HPP)(GLuint id,GLenum pname,GLint *params);

static inline void GetQueryObjectivARB(GLuint id,GLenum pname,GLint *params)
{
	static PFNGETQUERYOBJECTIVARBPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTIVARBPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectivARB","GL_ARB_occlusion_query"));
	 fn(id,pname,params);
}

typedef void (*PFNGETQUERYOBJECTUIVARBPROC_HPP)(GLuint id,GLenum pname,GLuint *params);

static inline void GetQueryObjectuivARB(GLuint id,GLenum pname,GLuint *params)
{
	static PFNGETQUERYOBJECTUIVARBPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTUIVARBPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectuivARB","GL_ARB_occlusion_query"));
	 fn(id,pname,params);
}
#ifndef GL_ARB_occlusion_query2

#define GL_ARB_occlusion_query2
#ifndef GL_ANY_SAMPLES_PASSED
#define GL_ANY_SAMPLES_PASSED                                           0x8C2F
#endif //GL_ANY_SAMPLES_PASSED

#endif //GL_ARB_occlusion_query2

#ifndef GL_ARB_pixel_buffer_object

#define GL_ARB_pixel_buffer_object
#ifndef GL_PIXEL_PACK_BUFFER_ARB
#define GL_PIXEL_PACK_BUFFER_ARB                                        0x88EB
#endif //GL_PIXEL_PACK_BUFFER_ARB
#ifndef GL_PIXEL_UNPACK_BUFFER_ARB
#define GL_PIXEL_UNPACK_BUFFER_ARB                                      0x88EC
#endif //GL_PIXEL_UNPACK_BUFFER_ARB
#ifndef GL_PIXEL_PACK_BUFFER_BINDING_ARB
#define GL_PIXEL_PACK_BUFFER_BINDING_ARB                                0x88ED
#endif //GL_PIXEL_PACK_BUFFER_BINDING_ARB
#ifndef GL_PIXEL_UNPACK_BUFFER_BINDING_ARB
#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB                              0x88EF
#endif //GL_PIXEL_UNPACK_BUFFER_BINDING_ARB

#endif //GL_ARB_pixel_buffer_object

#ifndef GL_ARB_point_parameters

#define GL_ARB_point_parameters
#ifndef GL_POINT_SIZE_MIN_ARB
#define GL_POINT_SIZE_MIN_ARB                                           0x8126
#endif //GL_POINT_SIZE_MIN_ARB
#ifndef GL_POINT_SIZE_MAX_ARB
#define GL_POINT_SIZE_MAX_ARB                                           0x8127
#endif //GL_POINT_SIZE_MAX_ARB
#ifndef GL_POINT_FADE_THRESHOLD_SIZE_ARB
#define GL_POINT_FADE_THRESHOLD_SIZE_ARB                                0x8128
#endif //GL_POINT_FADE_THRESHOLD_SIZE_ARB
#ifndef GL_POINT_DISTANCE_ATTENUATION_ARB
#define GL_POINT_DISTANCE_ATTENUATION_ARB                               0x8129
#endif //GL_POINT_DISTANCE_ATTENUATION_ARB

#endif //GL_ARB_point_parameters


typedef void (*PFNPOINTPARAMETERFARBPROC_HPP)(GLenum pname,GLfloat param);

static inline void PointParameterfARB(GLenum pname,GLfloat param)
{
	static PFNPOINTPARAMETERFARBPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFARBPROC_HPP>(_impl::_get_proc_address("glPointParameterfARB","GL_ARB_point_parameters"));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERFVARBPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void PointParameterfvARB(GLenum pname,const GLfloat *params)
{
	static PFNPOINTPARAMETERFVARBPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFVARBPROC_HPP>(_impl::_get_proc_address("glPointParameterfvARB","GL_ARB_point_parameters"));
	 fn(pname,params);
}
#ifndef GL_ARB_point_sprite

#define GL_ARB_point_sprite
#ifndef GL_POINT_SPRITE_ARB
#define GL_POINT_SPRITE_ARB                                             0x8861
#endif //GL_POINT_SPRITE_ARB
#ifndef GL_COORD_REPLACE_ARB
#define GL_COORD_REPLACE_ARB                                            0x8862
#endif //GL_COORD_REPLACE_ARB

#endif //GL_ARB_point_sprite

#ifndef GL_ARB_program_interface_query

#define GL_ARB_program_interface_query
#ifndef GL_UNIFORM
#define GL_UNIFORM                                                      0x92E1
#endif //GL_UNIFORM
#ifndef GL_UNIFORM_BLOCK
#define GL_UNIFORM_BLOCK                                                0x92E2
#endif //GL_UNIFORM_BLOCK
#ifndef GL_PROGRAM_INPUT
#define GL_PROGRAM_INPUT                                                0x92E3
#endif //GL_PROGRAM_INPUT
#ifndef GL_PROGRAM_OUTPUT
#define GL_PROGRAM_OUTPUT                                               0x92E4
#endif //GL_PROGRAM_OUTPUT
#ifndef GL_BUFFER_VARIABLE
#define GL_BUFFER_VARIABLE                                              0x92E5
#endif //GL_BUFFER_VARIABLE
#ifndef GL_SHADER_STORAGE_BLOCK
#define GL_SHADER_STORAGE_BLOCK                                         0x92E6
#endif //GL_SHADER_STORAGE_BLOCK
#ifndef GL_IS_PER_PATCH
#define GL_IS_PER_PATCH                                                 0x92E7
#endif //GL_IS_PER_PATCH
#ifndef GL_VERTEX_SUBROUTINE
#define GL_VERTEX_SUBROUTINE                                            0x92E8
#endif //GL_VERTEX_SUBROUTINE
#ifndef GL_TESS_CONTROL_SUBROUTINE
#define GL_TESS_CONTROL_SUBROUTINE                                      0x92E9
#endif //GL_TESS_CONTROL_SUBROUTINE
#ifndef GL_TESS_EVALUATION_SUBROUTINE
#define GL_TESS_EVALUATION_SUBROUTINE                                   0x92EA
#endif //GL_TESS_EVALUATION_SUBROUTINE
#ifndef GL_GEOMETRY_SUBROUTINE
#define GL_GEOMETRY_SUBROUTINE                                          0x92EB
#endif //GL_GEOMETRY_SUBROUTINE
#ifndef GL_FRAGMENT_SUBROUTINE
#define GL_FRAGMENT_SUBROUTINE                                          0x92EC
#endif //GL_FRAGMENT_SUBROUTINE
#ifndef GL_COMPUTE_SUBROUTINE
#define GL_COMPUTE_SUBROUTINE                                           0x92ED
#endif //GL_COMPUTE_SUBROUTINE
#ifndef GL_VERTEX_SUBROUTINE_UNIFORM
#define GL_VERTEX_SUBROUTINE_UNIFORM                                    0x92EE
#endif //GL_VERTEX_SUBROUTINE_UNIFORM
#ifndef GL_TESS_CONTROL_SUBROUTINE_UNIFORM
#define GL_TESS_CONTROL_SUBROUTINE_UNIFORM                              0x92EF
#endif //GL_TESS_CONTROL_SUBROUTINE_UNIFORM
#ifndef GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
#define GL_TESS_EVALUATION_SUBROUTINE_UNIFORM                           0x92F0
#endif //GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
#ifndef GL_GEOMETRY_SUBROUTINE_UNIFORM
#define GL_GEOMETRY_SUBROUTINE_UNIFORM                                  0x92F1
#endif //GL_GEOMETRY_SUBROUTINE_UNIFORM
#ifndef GL_FRAGMENT_SUBROUTINE_UNIFORM
#define GL_FRAGMENT_SUBROUTINE_UNIFORM                                  0x92F2
#endif //GL_FRAGMENT_SUBROUTINE_UNIFORM
#ifndef GL_COMPUTE_SUBROUTINE_UNIFORM
#define GL_COMPUTE_SUBROUTINE_UNIFORM                                   0x92F3
#endif //GL_COMPUTE_SUBROUTINE_UNIFORM
#ifndef GL_TRANSFORM_FEEDBACK_VARYING
#define GL_TRANSFORM_FEEDBACK_VARYING                                   0x92F4
#endif //GL_TRANSFORM_FEEDBACK_VARYING
#ifndef GL_ACTIVE_RESOURCES
#define GL_ACTIVE_RESOURCES                                             0x92F5
#endif //GL_ACTIVE_RESOURCES
#ifndef GL_MAX_NAME_LENGTH
#define GL_MAX_NAME_LENGTH                                              0x92F6
#endif //GL_MAX_NAME_LENGTH
#ifndef GL_MAX_NUM_ACTIVE_VARIABLES
#define GL_MAX_NUM_ACTIVE_VARIABLES                                     0x92F7
#endif //GL_MAX_NUM_ACTIVE_VARIABLES
#ifndef GL_MAX_NUM_COMPATIBLE_SUBROUTINES
#define GL_MAX_NUM_COMPATIBLE_SUBROUTINES                               0x92F8
#endif //GL_MAX_NUM_COMPATIBLE_SUBROUTINES
#ifndef GL_NAME_LENGTH
#define GL_NAME_LENGTH                                                  0x92F9
#endif //GL_NAME_LENGTH
#ifndef GL_TYPE
#define GL_TYPE                                                         0x92FA
#endif //GL_TYPE
#ifndef GL_ARRAY_SIZE
#define GL_ARRAY_SIZE                                                   0x92FB
#endif //GL_ARRAY_SIZE
#ifndef GL_OFFSET
#define GL_OFFSET                                                       0x92FC
#endif //GL_OFFSET
#ifndef GL_BLOCK_INDEX
#define GL_BLOCK_INDEX                                                  0x92FD
#endif //GL_BLOCK_INDEX
#ifndef GL_ARRAY_STRIDE
#define GL_ARRAY_STRIDE                                                 0x92FE
#endif //GL_ARRAY_STRIDE
#ifndef GL_MATRIX_STRIDE
#define GL_MATRIX_STRIDE                                                0x92FF
#endif //GL_MATRIX_STRIDE
#ifndef GL_IS_ROW_MAJOR
#define GL_IS_ROW_MAJOR                                                 0x9300
#endif //GL_IS_ROW_MAJOR
#ifndef GL_ATOMIC_COUNTER_BUFFER_INDEX
#define GL_ATOMIC_COUNTER_BUFFER_INDEX                                  0x9301
#endif //GL_ATOMIC_COUNTER_BUFFER_INDEX
#ifndef GL_BUFFER_BINDING
#define GL_BUFFER_BINDING                                               0x9302
#endif //GL_BUFFER_BINDING
#ifndef GL_BUFFER_DATA_SIZE
#define GL_BUFFER_DATA_SIZE                                             0x9303
#endif //GL_BUFFER_DATA_SIZE
#ifndef GL_NUM_ACTIVE_VARIABLES
#define GL_NUM_ACTIVE_VARIABLES                                         0x9304
#endif //GL_NUM_ACTIVE_VARIABLES
#ifndef GL_ACTIVE_VARIABLES
#define GL_ACTIVE_VARIABLES                                             0x9305
#endif //GL_ACTIVE_VARIABLES
#ifndef GL_REFERENCED_BY_VERTEX_SHADER
#define GL_REFERENCED_BY_VERTEX_SHADER                                  0x9306
#endif //GL_REFERENCED_BY_VERTEX_SHADER
#ifndef GL_REFERENCED_BY_TESS_CONTROL_SHADER
#define GL_REFERENCED_BY_TESS_CONTROL_SHADER                            0x9307
#endif //GL_REFERENCED_BY_TESS_CONTROL_SHADER
#ifndef GL_REFERENCED_BY_TESS_EVALUATION_SHADER
#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER                         0x9308
#endif //GL_REFERENCED_BY_TESS_EVALUATION_SHADER
#ifndef GL_REFERENCED_BY_GEOMETRY_SHADER
#define GL_REFERENCED_BY_GEOMETRY_SHADER                                0x9309
#endif //GL_REFERENCED_BY_GEOMETRY_SHADER
#ifndef GL_REFERENCED_BY_FRAGMENT_SHADER
#define GL_REFERENCED_BY_FRAGMENT_SHADER                                0x930A
#endif //GL_REFERENCED_BY_FRAGMENT_SHADER
#ifndef GL_REFERENCED_BY_COMPUTE_SHADER
#define GL_REFERENCED_BY_COMPUTE_SHADER                                 0x930B
#endif //GL_REFERENCED_BY_COMPUTE_SHADER
#ifndef GL_TOP_LEVEL_ARRAY_SIZE
#define GL_TOP_LEVEL_ARRAY_SIZE                                         0x930C
#endif //GL_TOP_LEVEL_ARRAY_SIZE
#ifndef GL_TOP_LEVEL_ARRAY_STRIDE
#define GL_TOP_LEVEL_ARRAY_STRIDE                                       0x930D
#endif //GL_TOP_LEVEL_ARRAY_STRIDE
#ifndef GL_LOCATION
#define GL_LOCATION                                                     0x930E
#endif //GL_LOCATION
#ifndef GL_LOCATION_INDEX
#define GL_LOCATION_INDEX                                               0x930F
#endif //GL_LOCATION_INDEX

#endif //GL_ARB_program_interface_query


typedef void (*PFNGETPROGRAMINTERFACEIVPROC_HPP)(GLuint program,GLenum programInterface,GLenum pname,GLint *params);

static inline void GetProgramInterfaceiv(GLuint program,GLenum programInterface,GLenum pname,GLint *params)
{
	static PFNGETPROGRAMINTERFACEIVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMINTERFACEIVPROC_HPP>(_impl::_get_proc_address("glGetProgramInterfaceiv","GL_ARB_program_interface_query"));
	 fn(program,programInterface,pname,params);
}

typedef GLuint (*PFNGETPROGRAMRESOURCEINDEXPROC_HPP)(GLuint program,GLenum programInterface,const GLchar *name);

static inline GLuint GetProgramResourceIndex(GLuint program,GLenum programInterface,const GLchar *name)
{
	static PFNGETPROGRAMRESOURCEINDEXPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMRESOURCEINDEXPROC_HPP>(_impl::_get_proc_address("glGetProgramResourceIndex","GL_ARB_program_interface_query"));
	return fn(program,programInterface,name);
}

typedef void (*PFNGETPROGRAMRESOURCENAMEPROC_HPP)(GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei *length,GLchar *name);

static inline void GetProgramResourceName(GLuint program,GLenum programInterface,GLuint index,GLsizei bufSize,GLsizei *length,GLchar *name)
{
	static PFNGETPROGRAMRESOURCENAMEPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMRESOURCENAMEPROC_HPP>(_impl::_get_proc_address("glGetProgramResourceName","GL_ARB_program_interface_query"));
	 fn(program,programInterface,index,bufSize,length,name);
}

typedef void (*PFNGETPROGRAMRESOURCEIVPROC_HPP)(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum *props,GLsizei bufSize,GLsizei *length,GLint *params);

static inline void GetProgramResourceiv(GLuint program,GLenum programInterface,GLuint index,GLsizei propCount,const GLenum *props,GLsizei bufSize,GLsizei *length,GLint *params)
{
	static PFNGETPROGRAMRESOURCEIVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMRESOURCEIVPROC_HPP>(_impl::_get_proc_address("glGetProgramResourceiv","GL_ARB_program_interface_query"));
	 fn(program,programInterface,index,propCount,props,bufSize,length,params);
}

typedef GLint (*PFNGETPROGRAMRESOURCELOCATIONPROC_HPP)(GLuint program,GLenum programInterface,const GLchar *name);

static inline GLint GetProgramResourceLocation(GLuint program,GLenum programInterface,const GLchar *name)
{
	static PFNGETPROGRAMRESOURCELOCATIONPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMRESOURCELOCATIONPROC_HPP>(_impl::_get_proc_address("glGetProgramResourceLocation","GL_ARB_program_interface_query"));
	return fn(program,programInterface,name);
}

typedef GLint (*PFNGETPROGRAMRESOURCELOCATIONINDEXPROC_HPP)(GLuint program,GLenum programInterface,const GLchar *name);

static inline GLint GetProgramResourceLocationIndex(GLuint program,GLenum programInterface,const GLchar *name)
{
	static PFNGETPROGRAMRESOURCELOCATIONINDEXPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMRESOURCELOCATIONINDEXPROC_HPP>(_impl::_get_proc_address("glGetProgramResourceLocationIndex","GL_ARB_program_interface_query"));
	return fn(program,programInterface,name);
}
#ifndef GL_ARB_provoking_vertex

#define GL_ARB_provoking_vertex

#endif //GL_ARB_provoking_vertex


typedef void (*PFNPROVOKINGVERTEXPROC_HPP)(GLenum mode);

static inline void ProvokingVertex(GLenum mode)
{
	static PFNPROVOKINGVERTEXPROC_HPP fn=reinterpret_cast<PFNPROVOKINGVERTEXPROC_HPP>(_impl::_get_proc_address("glProvokingVertex","GL_ARB_provoking_vertex"));
	 fn(mode);
}
#ifndef GL_ARB_robustness

#define GL_ARB_robustness
#ifndef GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB
#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB                           0x00000004
#endif //GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB
#ifndef GL_LOSE_CONTEXT_ON_RESET_ARB
#define GL_LOSE_CONTEXT_ON_RESET_ARB                                    0x8252
#endif //GL_LOSE_CONTEXT_ON_RESET_ARB
#ifndef GL_GUILTY_CONTEXT_RESET_ARB
#define GL_GUILTY_CONTEXT_RESET_ARB                                     0x8253
#endif //GL_GUILTY_CONTEXT_RESET_ARB
#ifndef GL_INNOCENT_CONTEXT_RESET_ARB
#define GL_INNOCENT_CONTEXT_RESET_ARB                                   0x8254
#endif //GL_INNOCENT_CONTEXT_RESET_ARB
#ifndef GL_UNKNOWN_CONTEXT_RESET_ARB
#define GL_UNKNOWN_CONTEXT_RESET_ARB                                    0x8255
#endif //GL_UNKNOWN_CONTEXT_RESET_ARB
#ifndef GL_RESET_NOTIFICATION_STRATEGY_ARB
#define GL_RESET_NOTIFICATION_STRATEGY_ARB                              0x8256
#endif //GL_RESET_NOTIFICATION_STRATEGY_ARB
#ifndef GL_NO_RESET_NOTIFICATION_ARB
#define GL_NO_RESET_NOTIFICATION_ARB                                    0x8261
#endif //GL_NO_RESET_NOTIFICATION_ARB

#endif //GL_ARB_robustness


typedef GLenum (*PFNGETGRAPHICSRESETSTATUSARBPROC_HPP)();

static inline GLenum GetGraphicsResetStatusARB()
{
	static PFNGETGRAPHICSRESETSTATUSARBPROC_HPP fn=reinterpret_cast<PFNGETGRAPHICSRESETSTATUSARBPROC_HPP>(_impl::_get_proc_address("glGetGraphicsResetStatusARB","GL_ARB_robustness"));
	return fn();
}

typedef void (*PFNGETNMAPDVARBPROC_HPP)(GLenum target,GLenum query,GLsizei bufSize,GLdouble *v);

static inline void GetnMapdvARB(GLenum target,GLenum query,GLsizei bufSize,GLdouble *v)
{
	static PFNGETNMAPDVARBPROC_HPP fn=reinterpret_cast<PFNGETNMAPDVARBPROC_HPP>(_impl::_get_proc_address("glGetnMapdvARB","GL_ARB_robustness"));
	 fn(target,query,bufSize,v);
}

typedef void (*PFNGETNMAPFVARBPROC_HPP)(GLenum target,GLenum query,GLsizei bufSize,GLfloat *v);

static inline void GetnMapfvARB(GLenum target,GLenum query,GLsizei bufSize,GLfloat *v)
{
	static PFNGETNMAPFVARBPROC_HPP fn=reinterpret_cast<PFNGETNMAPFVARBPROC_HPP>(_impl::_get_proc_address("glGetnMapfvARB","GL_ARB_robustness"));
	 fn(target,query,bufSize,v);
}

typedef void (*PFNGETNMAPIVARBPROC_HPP)(GLenum target,GLenum query,GLsizei bufSize,GLint *v);

static inline void GetnMapivARB(GLenum target,GLenum query,GLsizei bufSize,GLint *v)
{
	static PFNGETNMAPIVARBPROC_HPP fn=reinterpret_cast<PFNGETNMAPIVARBPROC_HPP>(_impl::_get_proc_address("glGetnMapivARB","GL_ARB_robustness"));
	 fn(target,query,bufSize,v);
}

typedef void (*PFNGETNPIXELMAPFVARBPROC_HPP)(GLenum map,GLsizei bufSize,GLfloat *values);

static inline void GetnPixelMapfvARB(GLenum map,GLsizei bufSize,GLfloat *values)
{
	static PFNGETNPIXELMAPFVARBPROC_HPP fn=reinterpret_cast<PFNGETNPIXELMAPFVARBPROC_HPP>(_impl::_get_proc_address("glGetnPixelMapfvARB","GL_ARB_robustness"));
	 fn(map,bufSize,values);
}

typedef void (*PFNGETNPIXELMAPUIVARBPROC_HPP)(GLenum map,GLsizei bufSize,GLuint *values);

static inline void GetnPixelMapuivARB(GLenum map,GLsizei bufSize,GLuint *values)
{
	static PFNGETNPIXELMAPUIVARBPROC_HPP fn=reinterpret_cast<PFNGETNPIXELMAPUIVARBPROC_HPP>(_impl::_get_proc_address("glGetnPixelMapuivARB","GL_ARB_robustness"));
	 fn(map,bufSize,values);
}

typedef void (*PFNGETNPIXELMAPUSVARBPROC_HPP)(GLenum map,GLsizei bufSize,GLushort *values);

static inline void GetnPixelMapusvARB(GLenum map,GLsizei bufSize,GLushort *values)
{
	static PFNGETNPIXELMAPUSVARBPROC_HPP fn=reinterpret_cast<PFNGETNPIXELMAPUSVARBPROC_HPP>(_impl::_get_proc_address("glGetnPixelMapusvARB","GL_ARB_robustness"));
	 fn(map,bufSize,values);
}

typedef void (*PFNGETNPOLYGONSTIPPLEARBPROC_HPP)(GLsizei bufSize,GLubyte *pattern);

static inline void GetnPolygonStippleARB(GLsizei bufSize,GLubyte *pattern)
{
	static PFNGETNPOLYGONSTIPPLEARBPROC_HPP fn=reinterpret_cast<PFNGETNPOLYGONSTIPPLEARBPROC_HPP>(_impl::_get_proc_address("glGetnPolygonStippleARB","GL_ARB_robustness"));
	 fn(bufSize,pattern);
}

typedef void (*PFNGETNCOLORTABLEARBPROC_HPP)(GLenum target,GLenum format,GLenum type,GLsizei bufSize,GLvoid *table);

static inline void GetnColorTableARB(GLenum target,GLenum format,GLenum type,GLsizei bufSize,GLvoid *table)
{
	static PFNGETNCOLORTABLEARBPROC_HPP fn=reinterpret_cast<PFNGETNCOLORTABLEARBPROC_HPP>(_impl::_get_proc_address("glGetnColorTableARB","GL_ARB_robustness"));
	 fn(target,format,type,bufSize,table);
}

typedef void (*PFNGETNCONVOLUTIONFILTERARBPROC_HPP)(GLenum target,GLenum format,GLenum type,GLsizei bufSize,GLvoid *image);

static inline void GetnConvolutionFilterARB(GLenum target,GLenum format,GLenum type,GLsizei bufSize,GLvoid *image)
{
	static PFNGETNCONVOLUTIONFILTERARBPROC_HPP fn=reinterpret_cast<PFNGETNCONVOLUTIONFILTERARBPROC_HPP>(_impl::_get_proc_address("glGetnConvolutionFilterARB","GL_ARB_robustness"));
	 fn(target,format,type,bufSize,image);
}

typedef void (*PFNGETNSEPARABLEFILTERARBPROC_HPP)(GLenum target,GLenum format,GLenum type,GLsizei rowBufSize,GLvoid *row,GLsizei columnBufSize,GLvoid *column,GLvoid *span);

static inline void GetnSeparableFilterARB(GLenum target,GLenum format,GLenum type,GLsizei rowBufSize,GLvoid *row,GLsizei columnBufSize,GLvoid *column,GLvoid *span)
{
	static PFNGETNSEPARABLEFILTERARBPROC_HPP fn=reinterpret_cast<PFNGETNSEPARABLEFILTERARBPROC_HPP>(_impl::_get_proc_address("glGetnSeparableFilterARB","GL_ARB_robustness"));
	 fn(target,format,type,rowBufSize,row,columnBufSize,column,span);
}

typedef void (*PFNGETNHISTOGRAMARBPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,GLvoid *values);

static inline void GetnHistogramARB(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,GLvoid *values)
{
	static PFNGETNHISTOGRAMARBPROC_HPP fn=reinterpret_cast<PFNGETNHISTOGRAMARBPROC_HPP>(_impl::_get_proc_address("glGetnHistogramARB","GL_ARB_robustness"));
	 fn(target,reset,format,type,bufSize,values);
}

typedef void (*PFNGETNMINMAXARBPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,GLvoid *values);

static inline void GetnMinmaxARB(GLenum target,GLboolean reset,GLenum format,GLenum type,GLsizei bufSize,GLvoid *values)
{
	static PFNGETNMINMAXARBPROC_HPP fn=reinterpret_cast<PFNGETNMINMAXARBPROC_HPP>(_impl::_get_proc_address("glGetnMinmaxARB","GL_ARB_robustness"));
	 fn(target,reset,format,type,bufSize,values);
}

typedef void (*PFNGETNTEXIMAGEARBPROC_HPP)(GLenum target,GLint level,GLenum format,GLenum type,GLsizei bufSize,GLvoid *img);

static inline void GetnTexImageARB(GLenum target,GLint level,GLenum format,GLenum type,GLsizei bufSize,GLvoid *img)
{
	static PFNGETNTEXIMAGEARBPROC_HPP fn=reinterpret_cast<PFNGETNTEXIMAGEARBPROC_HPP>(_impl::_get_proc_address("glGetnTexImageARB","GL_ARB_robustness"));
	 fn(target,level,format,type,bufSize,img);
}

typedef void (*PFNREADNPIXELSARBPROC_HPP)(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLvoid *data);

static inline void ReadnPixelsARB(GLint x,GLint y,GLsizei width,GLsizei height,GLenum format,GLenum type,GLsizei bufSize,GLvoid *data)
{
	static PFNREADNPIXELSARBPROC_HPP fn=reinterpret_cast<PFNREADNPIXELSARBPROC_HPP>(_impl::_get_proc_address("glReadnPixelsARB","GL_ARB_robustness"));
	 fn(x,y,width,height,format,type,bufSize,data);
}

typedef void (*PFNGETNCOMPRESSEDTEXIMAGEARBPROC_HPP)(GLenum target,GLint lod,GLsizei bufSize,GLvoid *img);

static inline void GetnCompressedTexImageARB(GLenum target,GLint lod,GLsizei bufSize,GLvoid *img)
{
	static PFNGETNCOMPRESSEDTEXIMAGEARBPROC_HPP fn=reinterpret_cast<PFNGETNCOMPRESSEDTEXIMAGEARBPROC_HPP>(_impl::_get_proc_address("glGetnCompressedTexImageARB","GL_ARB_robustness"));
	 fn(target,lod,bufSize,img);
}

typedef void (*PFNGETNUNIFORMFVARBPROC_HPP)(GLuint program,GLint location,GLsizei bufSize,GLfloat *params);

static inline void GetnUniformfvARB(GLuint program,GLint location,GLsizei bufSize,GLfloat *params)
{
	static PFNGETNUNIFORMFVARBPROC_HPP fn=reinterpret_cast<PFNGETNUNIFORMFVARBPROC_HPP>(_impl::_get_proc_address("glGetnUniformfvARB","GL_ARB_robustness"));
	 fn(program,location,bufSize,params);
}

typedef void (*PFNGETNUNIFORMIVARBPROC_HPP)(GLuint program,GLint location,GLsizei bufSize,GLint *params);

static inline void GetnUniformivARB(GLuint program,GLint location,GLsizei bufSize,GLint *params)
{
	static PFNGETNUNIFORMIVARBPROC_HPP fn=reinterpret_cast<PFNGETNUNIFORMIVARBPROC_HPP>(_impl::_get_proc_address("glGetnUniformivARB","GL_ARB_robustness"));
	 fn(program,location,bufSize,params);
}

typedef void (*PFNGETNUNIFORMUIVARBPROC_HPP)(GLuint program,GLint location,GLsizei bufSize,GLuint *params);

static inline void GetnUniformuivARB(GLuint program,GLint location,GLsizei bufSize,GLuint *params)
{
	static PFNGETNUNIFORMUIVARBPROC_HPP fn=reinterpret_cast<PFNGETNUNIFORMUIVARBPROC_HPP>(_impl::_get_proc_address("glGetnUniformuivARB","GL_ARB_robustness"));
	 fn(program,location,bufSize,params);
}

typedef void (*PFNGETNUNIFORMDVARBPROC_HPP)(GLuint program,GLint location,GLsizei bufSize,GLdouble *params);

static inline void GetnUniformdvARB(GLuint program,GLint location,GLsizei bufSize,GLdouble *params)
{
	static PFNGETNUNIFORMDVARBPROC_HPP fn=reinterpret_cast<PFNGETNUNIFORMDVARBPROC_HPP>(_impl::_get_proc_address("glGetnUniformdvARB","GL_ARB_robustness"));
	 fn(program,location,bufSize,params);
}
#ifndef GL_ARB_sample_shading

#define GL_ARB_sample_shading
#ifndef GL_SAMPLE_SHADING_ARB
#define GL_SAMPLE_SHADING_ARB                                           0x8C36
#endif //GL_SAMPLE_SHADING_ARB
#ifndef GL_MIN_SAMPLE_SHADING_VALUE_ARB
#define GL_MIN_SAMPLE_SHADING_VALUE_ARB                                 0x8C37
#endif //GL_MIN_SAMPLE_SHADING_VALUE_ARB

#endif //GL_ARB_sample_shading


typedef void (*PFNMINSAMPLESHADINGARBPROC_HPP)(GLfloat value);

static inline void MinSampleShadingARB(GLfloat value)
{
	static PFNMINSAMPLESHADINGARBPROC_HPP fn=reinterpret_cast<PFNMINSAMPLESHADINGARBPROC_HPP>(_impl::_get_proc_address("glMinSampleShadingARB","GL_ARB_sample_shading"));
	 fn(value);
}
#ifndef GL_ARB_sampler_objects

#define GL_ARB_sampler_objects
#ifndef GL_SAMPLER_BINDING
#define GL_SAMPLER_BINDING                                              0x8919
#endif //GL_SAMPLER_BINDING

#endif //GL_ARB_sampler_objects


typedef void (*PFNGENSAMPLERSPROC_HPP)(GLsizei count,GLuint *samplers);

static inline void GenSamplers(GLsizei count,GLuint *samplers)
{
	static PFNGENSAMPLERSPROC_HPP fn=reinterpret_cast<PFNGENSAMPLERSPROC_HPP>(_impl::_get_proc_address("glGenSamplers","GL_ARB_sampler_objects"));
	 fn(count,samplers);
}

typedef void (*PFNDELETESAMPLERSPROC_HPP)(GLsizei count,const GLuint *samplers);

static inline void DeleteSamplers(GLsizei count,const GLuint *samplers)
{
	static PFNDELETESAMPLERSPROC_HPP fn=reinterpret_cast<PFNDELETESAMPLERSPROC_HPP>(_impl::_get_proc_address("glDeleteSamplers","GL_ARB_sampler_objects"));
	 fn(count,samplers);
}

typedef GLboolean (*PFNISSAMPLERPROC_HPP)(GLuint sampler);

static inline GLboolean IsSampler(GLuint sampler)
{
	static PFNISSAMPLERPROC_HPP fn=reinterpret_cast<PFNISSAMPLERPROC_HPP>(_impl::_get_proc_address("glIsSampler","GL_ARB_sampler_objects"));
	return fn(sampler);
}

typedef void (*PFNBINDSAMPLERPROC_HPP)(GLuint unit,GLuint sampler);

static inline void BindSampler(GLuint unit,GLuint sampler)
{
	static PFNBINDSAMPLERPROC_HPP fn=reinterpret_cast<PFNBINDSAMPLERPROC_HPP>(_impl::_get_proc_address("glBindSampler","GL_ARB_sampler_objects"));
	 fn(unit,sampler);
}

typedef void (*PFNSAMPLERPARAMETERIPROC_HPP)(GLuint sampler,GLenum pname,GLint param);

static inline void SamplerParameteri(GLuint sampler,GLenum pname,GLint param)
{
	static PFNSAMPLERPARAMETERIPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERIPROC_HPP>(_impl::_get_proc_address("glSamplerParameteri","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNSAMPLERPARAMETERIVPROC_HPP)(GLuint sampler,GLenum pname,const GLint *param);

static inline void SamplerParameteriv(GLuint sampler,GLenum pname,const GLint *param)
{
	static PFNSAMPLERPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glSamplerParameteriv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNSAMPLERPARAMETERFPROC_HPP)(GLuint sampler,GLenum pname,GLfloat param);

static inline void SamplerParameterf(GLuint sampler,GLenum pname,GLfloat param)
{
	static PFNSAMPLERPARAMETERFPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERFPROC_HPP>(_impl::_get_proc_address("glSamplerParameterf","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNSAMPLERPARAMETERFVPROC_HPP)(GLuint sampler,GLenum pname,const GLfloat *param);

static inline void SamplerParameterfv(GLuint sampler,GLenum pname,const GLfloat *param)
{
	static PFNSAMPLERPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glSamplerParameterfv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNSAMPLERPARAMETERIIVPROC_HPP)(GLuint sampler,GLenum pname,const GLint *param);

static inline void SamplerParameterIiv(GLuint sampler,GLenum pname,const GLint *param)
{
	static PFNSAMPLERPARAMETERIIVPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERIIVPROC_HPP>(_impl::_get_proc_address("glSamplerParameterIiv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNSAMPLERPARAMETERIUIVPROC_HPP)(GLuint sampler,GLenum pname,const GLuint *param);

static inline void SamplerParameterIuiv(GLuint sampler,GLenum pname,const GLuint *param)
{
	static PFNSAMPLERPARAMETERIUIVPROC_HPP fn=reinterpret_cast<PFNSAMPLERPARAMETERIUIVPROC_HPP>(_impl::_get_proc_address("glSamplerParameterIuiv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,param);
}

typedef void (*PFNGETSAMPLERPARAMETERIVPROC_HPP)(GLuint sampler,GLenum pname,GLint *params);

static inline void GetSamplerParameteriv(GLuint sampler,GLenum pname,GLint *params)
{
	static PFNGETSAMPLERPARAMETERIVPROC_HPP fn=reinterpret_cast<PFNGETSAMPLERPARAMETERIVPROC_HPP>(_impl::_get_proc_address("glGetSamplerParameteriv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,params);
}

typedef void (*PFNGETSAMPLERPARAMETERIIVPROC_HPP)(GLuint sampler,GLenum pname,GLint *params);

static inline void GetSamplerParameterIiv(GLuint sampler,GLenum pname,GLint *params)
{
	static PFNGETSAMPLERPARAMETERIIVPROC_HPP fn=reinterpret_cast<PFNGETSAMPLERPARAMETERIIVPROC_HPP>(_impl::_get_proc_address("glGetSamplerParameterIiv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,params);
}

typedef void (*PFNGETSAMPLERPARAMETERFVPROC_HPP)(GLuint sampler,GLenum pname,GLfloat *params);

static inline void GetSamplerParameterfv(GLuint sampler,GLenum pname,GLfloat *params)
{
	static PFNGETSAMPLERPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNGETSAMPLERPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glGetSamplerParameterfv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,params);
}

typedef void (*PFNGETSAMPLERPARAMETERIUIVPROC_HPP)(GLuint sampler,GLenum pname,GLuint *params);

static inline void GetSamplerParameterIuiv(GLuint sampler,GLenum pname,GLuint *params)
{
	static PFNGETSAMPLERPARAMETERIUIVPROC_HPP fn=reinterpret_cast<PFNGETSAMPLERPARAMETERIUIVPROC_HPP>(_impl::_get_proc_address("glGetSamplerParameterIuiv","GL_ARB_sampler_objects"));
	 fn(sampler,pname,params);
}
#ifndef GL_ARB_seamless_cube_map

#define GL_ARB_seamless_cube_map

#endif //GL_ARB_seamless_cube_map

#ifndef GL_ARB_separate_shader_objects

#define GL_ARB_separate_shader_objects
#ifndef GL_VERTEX_SHADER_BIT
#define GL_VERTEX_SHADER_BIT                                            0x00000001
#endif //GL_VERTEX_SHADER_BIT
#ifndef GL_FRAGMENT_SHADER_BIT
#define GL_FRAGMENT_SHADER_BIT                                          0x00000002
#endif //GL_FRAGMENT_SHADER_BIT
#ifndef GL_GEOMETRY_SHADER_BIT
#define GL_GEOMETRY_SHADER_BIT                                          0x00000004
#endif //GL_GEOMETRY_SHADER_BIT
#ifndef GL_TESS_CONTROL_SHADER_BIT
#define GL_TESS_CONTROL_SHADER_BIT                                      0x00000008
#endif //GL_TESS_CONTROL_SHADER_BIT
#ifndef GL_TESS_EVALUATION_SHADER_BIT
#define GL_TESS_EVALUATION_SHADER_BIT                                   0x00000010
#endif //GL_TESS_EVALUATION_SHADER_BIT
#ifndef GL_PROGRAM_SEPARABLE
#define GL_PROGRAM_SEPARABLE                                            0x8258
#endif //GL_PROGRAM_SEPARABLE
#ifndef GL_ACTIVE_PROGRAM
#define GL_ACTIVE_PROGRAM                                               0x8259
#endif //GL_ACTIVE_PROGRAM
#ifndef GL_PROGRAM_PIPELINE_BINDING
#define GL_PROGRAM_PIPELINE_BINDING                                     0x825A
#endif //GL_PROGRAM_PIPELINE_BINDING
#ifndef GL_ALL_SHADER_BITS
#define GL_ALL_SHADER_BITS                                              0xFFFFFFFF
#endif //GL_ALL_SHADER_BITS

#endif //GL_ARB_separate_shader_objects


typedef void (*PFNUSEPROGRAMSTAGESPROC_HPP)(GLuint pipeline,GLbitfield stages,GLuint program);

static inline void UseProgramStages(GLuint pipeline,GLbitfield stages,GLuint program)
{
	static PFNUSEPROGRAMSTAGESPROC_HPP fn=reinterpret_cast<PFNUSEPROGRAMSTAGESPROC_HPP>(_impl::_get_proc_address("glUseProgramStages","GL_ARB_separate_shader_objects"));
	 fn(pipeline,stages,program);
}

typedef void (*PFNACTIVESHADERPROGRAMPROC_HPP)(GLuint pipeline,GLuint program);

static inline void ActiveShaderProgram(GLuint pipeline,GLuint program)
{
	static PFNACTIVESHADERPROGRAMPROC_HPP fn=reinterpret_cast<PFNACTIVESHADERPROGRAMPROC_HPP>(_impl::_get_proc_address("glActiveShaderProgram","GL_ARB_separate_shader_objects"));
	 fn(pipeline,program);
}

typedef GLuint (*PFNCREATESHADERPROGRAMVPROC_HPP)(GLenum type,GLsizei count,const GLchar* const *strings);

static inline GLuint CreateShaderProgramv(GLenum type,GLsizei count,const GLchar* const *strings)
{
	static PFNCREATESHADERPROGRAMVPROC_HPP fn=reinterpret_cast<PFNCREATESHADERPROGRAMVPROC_HPP>(_impl::_get_proc_address("glCreateShaderProgramv","GL_ARB_separate_shader_objects"));
	return fn(type,count,strings);
}

typedef void (*PFNBINDPROGRAMPIPELINEPROC_HPP)(GLuint pipeline);

static inline void BindProgramPipeline(GLuint pipeline)
{
	static PFNBINDPROGRAMPIPELINEPROC_HPP fn=reinterpret_cast<PFNBINDPROGRAMPIPELINEPROC_HPP>(_impl::_get_proc_address("glBindProgramPipeline","GL_ARB_separate_shader_objects"));
	 fn(pipeline);
}

typedef void (*PFNDELETEPROGRAMPIPELINESPROC_HPP)(GLsizei n,const GLuint *pipelines);

static inline void DeleteProgramPipelines(GLsizei n,const GLuint *pipelines)
{
	static PFNDELETEPROGRAMPIPELINESPROC_HPP fn=reinterpret_cast<PFNDELETEPROGRAMPIPELINESPROC_HPP>(_impl::_get_proc_address("glDeleteProgramPipelines","GL_ARB_separate_shader_objects"));
	 fn(n,pipelines);
}

typedef void (*PFNGENPROGRAMPIPELINESPROC_HPP)(GLsizei n,GLuint *pipelines);

static inline void GenProgramPipelines(GLsizei n,GLuint *pipelines)
{
	static PFNGENPROGRAMPIPELINESPROC_HPP fn=reinterpret_cast<PFNGENPROGRAMPIPELINESPROC_HPP>(_impl::_get_proc_address("glGenProgramPipelines","GL_ARB_separate_shader_objects"));
	 fn(n,pipelines);
}

typedef GLboolean (*PFNISPROGRAMPIPELINEPROC_HPP)(GLuint pipeline);

static inline GLboolean IsProgramPipeline(GLuint pipeline)
{
	static PFNISPROGRAMPIPELINEPROC_HPP fn=reinterpret_cast<PFNISPROGRAMPIPELINEPROC_HPP>(_impl::_get_proc_address("glIsProgramPipeline","GL_ARB_separate_shader_objects"));
	return fn(pipeline);
}

typedef void (*PFNGETPROGRAMPIPELINEIVPROC_HPP)(GLuint pipeline,GLenum pname,GLint *params);

static inline void GetProgramPipelineiv(GLuint pipeline,GLenum pname,GLint *params)
{
	static PFNGETPROGRAMPIPELINEIVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMPIPELINEIVPROC_HPP>(_impl::_get_proc_address("glGetProgramPipelineiv","GL_ARB_separate_shader_objects"));
	 fn(pipeline,pname,params);
}

typedef void (*PFNPROGRAMUNIFORM1IPROC_HPP)(GLuint program,GLint location,GLint v0);

static inline void ProgramUniform1i(GLuint program,GLint location,GLint v0)
{
	static PFNPROGRAMUNIFORM1IPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1IPROC_HPP>(_impl::_get_proc_address("glProgramUniform1i","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM1IVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform1iv(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM1IVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1IVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1iv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM1FPROC_HPP)(GLuint program,GLint location,GLfloat v0);

static inline void ProgramUniform1f(GLuint program,GLint location,GLfloat v0)
{
	static PFNPROGRAMUNIFORM1FPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1FPROC_HPP>(_impl::_get_proc_address("glProgramUniform1f","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM1FVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform1fv(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM1FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1FVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM1DPROC_HPP)(GLuint program,GLint location,GLdouble v0);

static inline void ProgramUniform1d(GLuint program,GLint location,GLdouble v0)
{
	static PFNPROGRAMUNIFORM1DPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1DPROC_HPP>(_impl::_get_proc_address("glProgramUniform1d","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM1DVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform1dv(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM1DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1DVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM1UIPROC_HPP)(GLuint program,GLint location,GLuint v0);

static inline void ProgramUniform1ui(GLuint program,GLint location,GLuint v0)
{
	static PFNPROGRAMUNIFORM1UIPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UIPROC_HPP>(_impl::_get_proc_address("glProgramUniform1ui","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM1UIVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform1uiv(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM1UIVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UIVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1uiv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2IPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1);

static inline void ProgramUniform2i(GLuint program,GLint location,GLint v0,GLint v1)
{
	static PFNPROGRAMUNIFORM2IPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2IPROC_HPP>(_impl::_get_proc_address("glProgramUniform2i","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM2IVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform2iv(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM2IVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2IVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2iv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2FPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1);

static inline void ProgramUniform2f(GLuint program,GLint location,GLfloat v0,GLfloat v1)
{
	static PFNPROGRAMUNIFORM2FPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2FPROC_HPP>(_impl::_get_proc_address("glProgramUniform2f","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM2FVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform2fv(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM2FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2FVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2DPROC_HPP)(GLuint program,GLint location,GLdouble v0,GLdouble v1);

static inline void ProgramUniform2d(GLuint program,GLint location,GLdouble v0,GLdouble v1)
{
	static PFNPROGRAMUNIFORM2DPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2DPROC_HPP>(_impl::_get_proc_address("glProgramUniform2d","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM2DVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform2dv(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM2DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2DVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2UIPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1);

static inline void ProgramUniform2ui(GLuint program,GLint location,GLuint v0,GLuint v1)
{
	static PFNPROGRAMUNIFORM2UIPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UIPROC_HPP>(_impl::_get_proc_address("glProgramUniform2ui","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM2UIVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform2uiv(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM2UIVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UIVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2uiv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3IPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1,GLint v2);

static inline void ProgramUniform3i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)
{
	static PFNPROGRAMUNIFORM3IPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3IPROC_HPP>(_impl::_get_proc_address("glProgramUniform3i","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM3IVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform3iv(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM3IVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3IVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3iv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3FPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2);

static inline void ProgramUniform3f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)
{
	static PFNPROGRAMUNIFORM3FPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3FPROC_HPP>(_impl::_get_proc_address("glProgramUniform3f","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM3FVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform3fv(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM3FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3FVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3DPROC_HPP)(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2);

static inline void ProgramUniform3d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2)
{
	static PFNPROGRAMUNIFORM3DPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3DPROC_HPP>(_impl::_get_proc_address("glProgramUniform3d","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM3DVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform3dv(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM3DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3DVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3UIPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2);

static inline void ProgramUniform3ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)
{
	static PFNPROGRAMUNIFORM3UIPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UIPROC_HPP>(_impl::_get_proc_address("glProgramUniform3ui","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM3UIVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform3uiv(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM3UIVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UIVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3uiv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4IPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3);

static inline void ProgramUniform4i(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)
{
	static PFNPROGRAMUNIFORM4IPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4IPROC_HPP>(_impl::_get_proc_address("glProgramUniform4i","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM4IVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform4iv(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM4IVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4IVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4iv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4FPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);

static inline void ProgramUniform4f(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)
{
	static PFNPROGRAMUNIFORM4FPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4FPROC_HPP>(_impl::_get_proc_address("glProgramUniform4f","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM4FVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform4fv(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM4FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4FVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4DPROC_HPP)(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2,GLdouble v3);

static inline void ProgramUniform4d(GLuint program,GLint location,GLdouble v0,GLdouble v1,GLdouble v2,GLdouble v3)
{
	static PFNPROGRAMUNIFORM4DPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4DPROC_HPP>(_impl::_get_proc_address("glProgramUniform4d","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM4DVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform4dv(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM4DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4DVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4UIPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);

static inline void ProgramUniform4ui(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)
{
	static PFNPROGRAMUNIFORM4UIPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UIPROC_HPP>(_impl::_get_proc_address("glProgramUniform4ui","GL_ARB_separate_shader_objects"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM4UIVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform4uiv(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM4UIVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UIVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4uiv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X3FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X3FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X3FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x3fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X2FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X2FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X2FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x2fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X4FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X4FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X4FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x4fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X2FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4x2fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X2FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X2FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x2fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X4FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3x4fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X4FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X4FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x4fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X3FVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4x3fv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X3FVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X3FVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x3fv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X3DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X3DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X3DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x3dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X2DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X2DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X2DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x2dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X4DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X4DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X4DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x4dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X2DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4x2dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X2DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X2DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x2dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X4DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3x4dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X4DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X4DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x4dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X3DVPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4x3dv(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X3DVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X3DVPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x3dv","GL_ARB_separate_shader_objects"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNVALIDATEPROGRAMPIPELINEPROC_HPP)(GLuint pipeline);

static inline void ValidateProgramPipeline(GLuint pipeline)
{
	static PFNVALIDATEPROGRAMPIPELINEPROC_HPP fn=reinterpret_cast<PFNVALIDATEPROGRAMPIPELINEPROC_HPP>(_impl::_get_proc_address("glValidateProgramPipeline","GL_ARB_separate_shader_objects"));
	 fn(pipeline);
}

typedef void (*PFNGETPROGRAMPIPELINEINFOLOGPROC_HPP)(GLuint pipeline,GLsizei bufSize,GLsizei *length,GLchar *infoLog);

static inline void GetProgramPipelineInfoLog(GLuint pipeline,GLsizei bufSize,GLsizei *length,GLchar *infoLog)
{
	static PFNGETPROGRAMPIPELINEINFOLOGPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMPIPELINEINFOLOGPROC_HPP>(_impl::_get_proc_address("glGetProgramPipelineInfoLog","GL_ARB_separate_shader_objects"));
	 fn(pipeline,bufSize,length,infoLog);
}
#ifndef GL_ARB_shader_atomic_counters

#define GL_ARB_shader_atomic_counters
#ifndef GL_ATOMIC_COUNTER_BUFFER
#define GL_ATOMIC_COUNTER_BUFFER                                        0x92C0
#endif //GL_ATOMIC_COUNTER_BUFFER
#ifndef GL_ATOMIC_COUNTER_BUFFER_BINDING
#define GL_ATOMIC_COUNTER_BUFFER_BINDING                                0x92C1
#endif //GL_ATOMIC_COUNTER_BUFFER_BINDING
#ifndef GL_ATOMIC_COUNTER_BUFFER_START
#define GL_ATOMIC_COUNTER_BUFFER_START                                  0x92C2
#endif //GL_ATOMIC_COUNTER_BUFFER_START
#ifndef GL_ATOMIC_COUNTER_BUFFER_SIZE
#define GL_ATOMIC_COUNTER_BUFFER_SIZE                                   0x92C3
#endif //GL_ATOMIC_COUNTER_BUFFER_SIZE
#ifndef GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE
#define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE                              0x92C4
#endif //GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE
#ifndef GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS
#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS                 0x92C5
#endif //GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS
#ifndef GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES
#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES          0x92C6
#endif //GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER            0x92C7
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER      0x92C8
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER   0x92C9
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER          0x92CA
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER
#ifndef GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER          0x92CB
#endif //GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER
#ifndef GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS                            0x92CC
#endif //GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS                      0x92CD
#endif //GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS                   0x92CE
#endif //GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS                          0x92CF
#endif //GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS                          0x92D0
#endif //GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS
#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS                          0x92D1
#endif //GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS
#ifndef GL_MAX_VERTEX_ATOMIC_COUNTERS
#define GL_MAX_VERTEX_ATOMIC_COUNTERS                                   0x92D2
#endif //GL_MAX_VERTEX_ATOMIC_COUNTERS
#ifndef GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS
#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS                             0x92D3
#endif //GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS
#ifndef GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS
#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS                          0x92D4
#endif //GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS
#ifndef GL_MAX_GEOMETRY_ATOMIC_COUNTERS
#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS                                 0x92D5
#endif //GL_MAX_GEOMETRY_ATOMIC_COUNTERS
#ifndef GL_MAX_FRAGMENT_ATOMIC_COUNTERS
#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS                                 0x92D6
#endif //GL_MAX_FRAGMENT_ATOMIC_COUNTERS
#ifndef GL_MAX_COMBINED_ATOMIC_COUNTERS
#define GL_MAX_COMBINED_ATOMIC_COUNTERS                                 0x92D7
#endif //GL_MAX_COMBINED_ATOMIC_COUNTERS
#ifndef GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE
#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE                               0x92D8
#endif //GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE
#ifndef GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS                                0x92D9
#endif //GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
#ifndef GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX
#define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX                          0x92DA
#endif //GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX
#ifndef GL_UNSIGNED_INT_ATOMIC_COUNTER
#define GL_UNSIGNED_INT_ATOMIC_COUNTER                                  0x92DB
#endif //GL_UNSIGNED_INT_ATOMIC_COUNTER
#ifndef GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS
#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS                           0x92DC
#endif //GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS

#endif //GL_ARB_shader_atomic_counters


typedef void (*PFNGETACTIVEATOMICCOUNTERBUFFERIVPROC_HPP)(GLuint program,GLuint bufferIndex,GLenum pname,GLint *params);

static inline void GetActiveAtomicCounterBufferiv(GLuint program,GLuint bufferIndex,GLenum pname,GLint *params)
{
	static PFNGETACTIVEATOMICCOUNTERBUFFERIVPROC_HPP fn=reinterpret_cast<PFNGETACTIVEATOMICCOUNTERBUFFERIVPROC_HPP>(_impl::_get_proc_address("glGetActiveAtomicCounterBufferiv","GL_ARB_shader_atomic_counters"));
	 fn(program,bufferIndex,pname,params);
}
#ifndef GL_ARB_shader_image_load_store

#define GL_ARB_shader_image_load_store
#ifndef GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT
#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT                              0x00000001
#endif //GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT
#ifndef GL_ELEMENT_ARRAY_BARRIER_BIT
#define GL_ELEMENT_ARRAY_BARRIER_BIT                                    0x00000002
#endif //GL_ELEMENT_ARRAY_BARRIER_BIT
#ifndef GL_UNIFORM_BARRIER_BIT
#define GL_UNIFORM_BARRIER_BIT                                          0x00000004
#endif //GL_UNIFORM_BARRIER_BIT
#ifndef GL_TEXTURE_FETCH_BARRIER_BIT
#define GL_TEXTURE_FETCH_BARRIER_BIT                                    0x00000008
#endif //GL_TEXTURE_FETCH_BARRIER_BIT
#ifndef GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT                              0x00000020
#endif //GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
#ifndef GL_COMMAND_BARRIER_BIT
#define GL_COMMAND_BARRIER_BIT                                          0x00000040
#endif //GL_COMMAND_BARRIER_BIT
#ifndef GL_PIXEL_BUFFER_BARRIER_BIT
#define GL_PIXEL_BUFFER_BARRIER_BIT                                     0x00000080
#endif //GL_PIXEL_BUFFER_BARRIER_BIT
#ifndef GL_TEXTURE_UPDATE_BARRIER_BIT
#define GL_TEXTURE_UPDATE_BARRIER_BIT                                   0x00000100
#endif //GL_TEXTURE_UPDATE_BARRIER_BIT
#ifndef GL_BUFFER_UPDATE_BARRIER_BIT
#define GL_BUFFER_UPDATE_BARRIER_BIT                                    0x00000200
#endif //GL_BUFFER_UPDATE_BARRIER_BIT
#ifndef GL_FRAMEBUFFER_BARRIER_BIT
#define GL_FRAMEBUFFER_BARRIER_BIT                                      0x00000400
#endif //GL_FRAMEBUFFER_BARRIER_BIT
#ifndef GL_TRANSFORM_FEEDBACK_BARRIER_BIT
#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT                               0x00000800
#endif //GL_TRANSFORM_FEEDBACK_BARRIER_BIT
#ifndef GL_ATOMIC_COUNTER_BARRIER_BIT
#define GL_ATOMIC_COUNTER_BARRIER_BIT                                   0x00001000
#endif //GL_ATOMIC_COUNTER_BARRIER_BIT
#ifndef GL_MAX_IMAGE_UNITS
#define GL_MAX_IMAGE_UNITS                                              0x8F38
#endif //GL_MAX_IMAGE_UNITS
#ifndef GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS
#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS                0x8F39
#endif //GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS
#ifndef GL_IMAGE_BINDING_NAME
#define GL_IMAGE_BINDING_NAME                                           0x8F3A
#endif //GL_IMAGE_BINDING_NAME
#ifndef GL_IMAGE_BINDING_LEVEL
#define GL_IMAGE_BINDING_LEVEL                                          0x8F3B
#endif //GL_IMAGE_BINDING_LEVEL
#ifndef GL_IMAGE_BINDING_LAYERED
#define GL_IMAGE_BINDING_LAYERED                                        0x8F3C
#endif //GL_IMAGE_BINDING_LAYERED
#ifndef GL_IMAGE_BINDING_LAYER
#define GL_IMAGE_BINDING_LAYER                                          0x8F3D
#endif //GL_IMAGE_BINDING_LAYER
#ifndef GL_IMAGE_BINDING_ACCESS
#define GL_IMAGE_BINDING_ACCESS                                         0x8F3E
#endif //GL_IMAGE_BINDING_ACCESS
#ifndef GL_IMAGE_1D
#define GL_IMAGE_1D                                                     0x904C
#endif //GL_IMAGE_1D
#ifndef GL_IMAGE_2D
#define GL_IMAGE_2D                                                     0x904D
#endif //GL_IMAGE_2D
#ifndef GL_IMAGE_3D
#define GL_IMAGE_3D                                                     0x904E
#endif //GL_IMAGE_3D
#ifndef GL_IMAGE_2D_RECT
#define GL_IMAGE_2D_RECT                                                0x904F
#endif //GL_IMAGE_2D_RECT
#ifndef GL_IMAGE_CUBE
#define GL_IMAGE_CUBE                                                   0x9050
#endif //GL_IMAGE_CUBE
#ifndef GL_IMAGE_BUFFER
#define GL_IMAGE_BUFFER                                                 0x9051
#endif //GL_IMAGE_BUFFER
#ifndef GL_IMAGE_1D_ARRAY
#define GL_IMAGE_1D_ARRAY                                               0x9052
#endif //GL_IMAGE_1D_ARRAY
#ifndef GL_IMAGE_2D_ARRAY
#define GL_IMAGE_2D_ARRAY                                               0x9053
#endif //GL_IMAGE_2D_ARRAY
#ifndef GL_IMAGE_CUBE_MAP_ARRAY
#define GL_IMAGE_CUBE_MAP_ARRAY                                         0x9054
#endif //GL_IMAGE_CUBE_MAP_ARRAY
#ifndef GL_IMAGE_2D_MULTISAMPLE
#define GL_IMAGE_2D_MULTISAMPLE                                         0x9055
#endif //GL_IMAGE_2D_MULTISAMPLE
#ifndef GL_IMAGE_2D_MULTISAMPLE_ARRAY
#define GL_IMAGE_2D_MULTISAMPLE_ARRAY                                   0x9056
#endif //GL_IMAGE_2D_MULTISAMPLE_ARRAY
#ifndef GL_INT_IMAGE_1D
#define GL_INT_IMAGE_1D                                                 0x9057
#endif //GL_INT_IMAGE_1D
#ifndef GL_INT_IMAGE_2D
#define GL_INT_IMAGE_2D                                                 0x9058
#endif //GL_INT_IMAGE_2D
#ifndef GL_INT_IMAGE_3D
#define GL_INT_IMAGE_3D                                                 0x9059
#endif //GL_INT_IMAGE_3D
#ifndef GL_INT_IMAGE_2D_RECT
#define GL_INT_IMAGE_2D_RECT                                            0x905A
#endif //GL_INT_IMAGE_2D_RECT
#ifndef GL_INT_IMAGE_CUBE
#define GL_INT_IMAGE_CUBE                                               0x905B
#endif //GL_INT_IMAGE_CUBE
#ifndef GL_INT_IMAGE_BUFFER
#define GL_INT_IMAGE_BUFFER                                             0x905C
#endif //GL_INT_IMAGE_BUFFER
#ifndef GL_INT_IMAGE_1D_ARRAY
#define GL_INT_IMAGE_1D_ARRAY                                           0x905D
#endif //GL_INT_IMAGE_1D_ARRAY
#ifndef GL_INT_IMAGE_2D_ARRAY
#define GL_INT_IMAGE_2D_ARRAY                                           0x905E
#endif //GL_INT_IMAGE_2D_ARRAY
#ifndef GL_INT_IMAGE_CUBE_MAP_ARRAY
#define GL_INT_IMAGE_CUBE_MAP_ARRAY                                     0x905F
#endif //GL_INT_IMAGE_CUBE_MAP_ARRAY
#ifndef GL_INT_IMAGE_2D_MULTISAMPLE
#define GL_INT_IMAGE_2D_MULTISAMPLE                                     0x9060
#endif //GL_INT_IMAGE_2D_MULTISAMPLE
#ifndef GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY
#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY                               0x9061
#endif //GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY
#ifndef GL_UNSIGNED_INT_IMAGE_1D
#define GL_UNSIGNED_INT_IMAGE_1D                                        0x9062
#endif //GL_UNSIGNED_INT_IMAGE_1D
#ifndef GL_UNSIGNED_INT_IMAGE_2D
#define GL_UNSIGNED_INT_IMAGE_2D                                        0x9063
#endif //GL_UNSIGNED_INT_IMAGE_2D
#ifndef GL_UNSIGNED_INT_IMAGE_3D
#define GL_UNSIGNED_INT_IMAGE_3D                                        0x9064
#endif //GL_UNSIGNED_INT_IMAGE_3D
#ifndef GL_UNSIGNED_INT_IMAGE_2D_RECT
#define GL_UNSIGNED_INT_IMAGE_2D_RECT                                   0x9065
#endif //GL_UNSIGNED_INT_IMAGE_2D_RECT
#ifndef GL_UNSIGNED_INT_IMAGE_CUBE
#define GL_UNSIGNED_INT_IMAGE_CUBE                                      0x9066
#endif //GL_UNSIGNED_INT_IMAGE_CUBE
#ifndef GL_UNSIGNED_INT_IMAGE_BUFFER
#define GL_UNSIGNED_INT_IMAGE_BUFFER                                    0x9067
#endif //GL_UNSIGNED_INT_IMAGE_BUFFER
#ifndef GL_UNSIGNED_INT_IMAGE_1D_ARRAY
#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY                                  0x9068
#endif //GL_UNSIGNED_INT_IMAGE_1D_ARRAY
#ifndef GL_UNSIGNED_INT_IMAGE_2D_ARRAY
#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY                                  0x9069
#endif //GL_UNSIGNED_INT_IMAGE_2D_ARRAY
#ifndef GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY                            0x906A
#endif //GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY
#ifndef GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE                            0x906B
#endif //GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE
#ifndef GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY                      0x906C
#endif //GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
#ifndef GL_MAX_IMAGE_SAMPLES
#define GL_MAX_IMAGE_SAMPLES                                            0x906D
#endif //GL_MAX_IMAGE_SAMPLES
#ifndef GL_IMAGE_BINDING_FORMAT
#define GL_IMAGE_BINDING_FORMAT                                         0x906E
#endif //GL_IMAGE_BINDING_FORMAT
#ifndef GL_ALL_BARRIER_BITS
#define GL_ALL_BARRIER_BITS                                             0xFFFFFFFF
#endif //GL_ALL_BARRIER_BITS

#endif //GL_ARB_shader_image_load_store


typedef void (*PFNBINDIMAGETEXTUREPROC_HPP)(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format);

static inline void BindImageTexture(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)
{
	static PFNBINDIMAGETEXTUREPROC_HPP fn=reinterpret_cast<PFNBINDIMAGETEXTUREPROC_HPP>(_impl::_get_proc_address("glBindImageTexture","GL_ARB_shader_image_load_store"));
	 fn(unit,texture,level,layered,layer,access,format);
}

typedef void (*PFNMEMORYBARRIERPROC_HPP)(GLbitfield barriers);

static inline void MemoryBarrier(GLbitfield barriers)
{
	static PFNMEMORYBARRIERPROC_HPP fn=reinterpret_cast<PFNMEMORYBARRIERPROC_HPP>(_impl::_get_proc_address("glMemoryBarrier","GL_ARB_shader_image_load_store"));
	 fn(barriers);
}
#ifndef GL_ARB_shader_objects

#define GL_ARB_shader_objects

#endif //GL_ARB_shader_objects


typedef void (*PFNDELETEOBJECTARBPROC_HPP)(GLhandleARB obj);

static inline void DeleteObjectARB(GLhandleARB obj)
{
	static PFNDELETEOBJECTARBPROC_HPP fn=reinterpret_cast<PFNDELETEOBJECTARBPROC_HPP>(_impl::_get_proc_address("glDeleteObjectARB","GL_ARB_shader_objects"));
	 fn(obj);
}

typedef GLhandleARB (*PFNGETHANDLEARBPROC_HPP)(GLenum pname);

static inline GLhandleARB GetHandleARB(GLenum pname)
{
	static PFNGETHANDLEARBPROC_HPP fn=reinterpret_cast<PFNGETHANDLEARBPROC_HPP>(_impl::_get_proc_address("glGetHandleARB","GL_ARB_shader_objects"));
	return fn(pname);
}

typedef void (*PFNDETACHOBJECTARBPROC_HPP)(GLhandleARB containerObj,GLhandleARB attachedObj);

static inline void DetachObjectARB(GLhandleARB containerObj,GLhandleARB attachedObj)
{
	static PFNDETACHOBJECTARBPROC_HPP fn=reinterpret_cast<PFNDETACHOBJECTARBPROC_HPP>(_impl::_get_proc_address("glDetachObjectARB","GL_ARB_shader_objects"));
	 fn(containerObj,attachedObj);
}

typedef GLhandleARB (*PFNCREATESHADEROBJECTARBPROC_HPP)(GLenum shaderType);

static inline GLhandleARB CreateShaderObjectARB(GLenum shaderType)
{
	static PFNCREATESHADEROBJECTARBPROC_HPP fn=reinterpret_cast<PFNCREATESHADEROBJECTARBPROC_HPP>(_impl::_get_proc_address("glCreateShaderObjectARB","GL_ARB_shader_objects"));
	return fn(shaderType);
}

typedef void (*PFNSHADERSOURCEARBPROC_HPP)(GLhandleARB shaderObj,GLsizei count,const GLcharARB* *string,const GLint *length);

static inline void ShaderSourceARB(GLhandleARB shaderObj,GLsizei count,const GLcharARB* *string,const GLint *length)
{
	static PFNSHADERSOURCEARBPROC_HPP fn=reinterpret_cast<PFNSHADERSOURCEARBPROC_HPP>(_impl::_get_proc_address("glShaderSourceARB","GL_ARB_shader_objects"));
	 fn(shaderObj,count,string,length);
}

typedef void (*PFNCOMPILESHADERARBPROC_HPP)(GLhandleARB shaderObj);

static inline void CompileShaderARB(GLhandleARB shaderObj)
{
	static PFNCOMPILESHADERARBPROC_HPP fn=reinterpret_cast<PFNCOMPILESHADERARBPROC_HPP>(_impl::_get_proc_address("glCompileShaderARB","GL_ARB_shader_objects"));
	 fn(shaderObj);
}

typedef GLhandleARB (*PFNCREATEPROGRAMOBJECTARBPROC_HPP)();

static inline GLhandleARB CreateProgramObjectARB()
{
	static PFNCREATEPROGRAMOBJECTARBPROC_HPP fn=reinterpret_cast<PFNCREATEPROGRAMOBJECTARBPROC_HPP>(_impl::_get_proc_address("glCreateProgramObjectARB","GL_ARB_shader_objects"));
	return fn();
}

typedef void (*PFNATTACHOBJECTARBPROC_HPP)(GLhandleARB containerObj,GLhandleARB obj);

static inline void AttachObjectARB(GLhandleARB containerObj,GLhandleARB obj)
{
	static PFNATTACHOBJECTARBPROC_HPP fn=reinterpret_cast<PFNATTACHOBJECTARBPROC_HPP>(_impl::_get_proc_address("glAttachObjectARB","GL_ARB_shader_objects"));
	 fn(containerObj,obj);
}

typedef void (*PFNLINKPROGRAMARBPROC_HPP)(GLhandleARB programObj);

static inline void LinkProgramARB(GLhandleARB programObj)
{
	static PFNLINKPROGRAMARBPROC_HPP fn=reinterpret_cast<PFNLINKPROGRAMARBPROC_HPP>(_impl::_get_proc_address("glLinkProgramARB","GL_ARB_shader_objects"));
	 fn(programObj);
}

typedef void (*PFNUSEPROGRAMOBJECTARBPROC_HPP)(GLhandleARB programObj);

static inline void UseProgramObjectARB(GLhandleARB programObj)
{
	static PFNUSEPROGRAMOBJECTARBPROC_HPP fn=reinterpret_cast<PFNUSEPROGRAMOBJECTARBPROC_HPP>(_impl::_get_proc_address("glUseProgramObjectARB","GL_ARB_shader_objects"));
	 fn(programObj);
}

typedef void (*PFNVALIDATEPROGRAMARBPROC_HPP)(GLhandleARB programObj);

static inline void ValidateProgramARB(GLhandleARB programObj)
{
	static PFNVALIDATEPROGRAMARBPROC_HPP fn=reinterpret_cast<PFNVALIDATEPROGRAMARBPROC_HPP>(_impl::_get_proc_address("glValidateProgramARB","GL_ARB_shader_objects"));
	 fn(programObj);
}

typedef void (*PFNUNIFORM1FARBPROC_HPP)(GLint location,GLfloat v0);

static inline void Uniform1fARB(GLint location,GLfloat v0)
{
	static PFNUNIFORM1FARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM1FARBPROC_HPP>(_impl::_get_proc_address("glUniform1fARB","GL_ARB_shader_objects"));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2FARBPROC_HPP)(GLint location,GLfloat v0,GLfloat v1);

static inline void Uniform2fARB(GLint location,GLfloat v0,GLfloat v1)
{
	static PFNUNIFORM2FARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM2FARBPROC_HPP>(_impl::_get_proc_address("glUniform2fARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3FARBPROC_HPP)(GLint location,GLfloat v0,GLfloat v1,GLfloat v2);

static inline void Uniform3fARB(GLint location,GLfloat v0,GLfloat v1,GLfloat v2)
{
	static PFNUNIFORM3FARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM3FARBPROC_HPP>(_impl::_get_proc_address("glUniform3fARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4FARBPROC_HPP)(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);

static inline void Uniform4fARB(GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)
{
	static PFNUNIFORM4FARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM4FARBPROC_HPP>(_impl::_get_proc_address("glUniform4fARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1IARBPROC_HPP)(GLint location,GLint v0);

static inline void Uniform1iARB(GLint location,GLint v0)
{
	static PFNUNIFORM1IARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM1IARBPROC_HPP>(_impl::_get_proc_address("glUniform1iARB","GL_ARB_shader_objects"));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2IARBPROC_HPP)(GLint location,GLint v0,GLint v1);

static inline void Uniform2iARB(GLint location,GLint v0,GLint v1)
{
	static PFNUNIFORM2IARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM2IARBPROC_HPP>(_impl::_get_proc_address("glUniform2iARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3IARBPROC_HPP)(GLint location,GLint v0,GLint v1,GLint v2);

static inline void Uniform3iARB(GLint location,GLint v0,GLint v1,GLint v2)
{
	static PFNUNIFORM3IARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM3IARBPROC_HPP>(_impl::_get_proc_address("glUniform3iARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4IARBPROC_HPP)(GLint location,GLint v0,GLint v1,GLint v2,GLint v3);

static inline void Uniform4iARB(GLint location,GLint v0,GLint v1,GLint v2,GLint v3)
{
	static PFNUNIFORM4IARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM4IARBPROC_HPP>(_impl::_get_proc_address("glUniform4iARB","GL_ARB_shader_objects"));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1FVARBPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform1fvARB(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM1FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM1FVARBPROC_HPP>(_impl::_get_proc_address("glUniform1fvARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2FVARBPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform2fvARB(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM2FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM2FVARBPROC_HPP>(_impl::_get_proc_address("glUniform2fvARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3FVARBPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform3fvARB(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM3FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM3FVARBPROC_HPP>(_impl::_get_proc_address("glUniform3fvARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4FVARBPROC_HPP)(GLint location,GLsizei count,const GLfloat *value);

static inline void Uniform4fvARB(GLint location,GLsizei count,const GLfloat *value)
{
	static PFNUNIFORM4FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM4FVARBPROC_HPP>(_impl::_get_proc_address("glUniform4fvARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM1IVARBPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform1ivARB(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM1IVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM1IVARBPROC_HPP>(_impl::_get_proc_address("glUniform1ivARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2IVARBPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform2ivARB(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM2IVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM2IVARBPROC_HPP>(_impl::_get_proc_address("glUniform2ivARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3IVARBPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform3ivARB(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM3IVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM3IVARBPROC_HPP>(_impl::_get_proc_address("glUniform3ivARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4IVARBPROC_HPP)(GLint location,GLsizei count,const GLint *value);

static inline void Uniform4ivARB(GLint location,GLsizei count,const GLint *value)
{
	static PFNUNIFORM4IVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORM4IVARBPROC_HPP>(_impl::_get_proc_address("glUniform4ivARB","GL_ARB_shader_objects"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORMMATRIX2FVARBPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix2fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX2FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX2FVARBPROC_HPP>(_impl::_get_proc_address("glUniformMatrix2fvARB","GL_ARB_shader_objects"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX3FVARBPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix3fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX3FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX3FVARBPROC_HPP>(_impl::_get_proc_address("glUniformMatrix3fvARB","GL_ARB_shader_objects"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNUNIFORMMATRIX4FVARBPROC_HPP)(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void UniformMatrix4fvARB(GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNUNIFORMMATRIX4FVARBPROC_HPP fn=reinterpret_cast<PFNUNIFORMMATRIX4FVARBPROC_HPP>(_impl::_get_proc_address("glUniformMatrix4fvARB","GL_ARB_shader_objects"));
	 fn(location,count,transpose,value);
}

typedef void (*PFNGETOBJECTPARAMETERFVARBPROC_HPP)(GLhandleARB obj,GLenum pname,GLfloat *params);

static inline void GetObjectParameterfvARB(GLhandleARB obj,GLenum pname,GLfloat *params)
{
	static PFNGETOBJECTPARAMETERFVARBPROC_HPP fn=reinterpret_cast<PFNGETOBJECTPARAMETERFVARBPROC_HPP>(_impl::_get_proc_address("glGetObjectParameterfvARB","GL_ARB_shader_objects"));
	 fn(obj,pname,params);
}

typedef void (*PFNGETOBJECTPARAMETERIVARBPROC_HPP)(GLhandleARB obj,GLenum pname,GLint *params);

static inline void GetObjectParameterivARB(GLhandleARB obj,GLenum pname,GLint *params)
{
	static PFNGETOBJECTPARAMETERIVARBPROC_HPP fn=reinterpret_cast<PFNGETOBJECTPARAMETERIVARBPROC_HPP>(_impl::_get_proc_address("glGetObjectParameterivARB","GL_ARB_shader_objects"));
	 fn(obj,pname,params);
}

typedef void (*PFNGETINFOLOGARBPROC_HPP)(GLhandleARB obj,GLsizei maxLength,GLsizei *length,GLcharARB *infoLog);

static inline void GetInfoLogARB(GLhandleARB obj,GLsizei maxLength,GLsizei *length,GLcharARB *infoLog)
{
	static PFNGETINFOLOGARBPROC_HPP fn=reinterpret_cast<PFNGETINFOLOGARBPROC_HPP>(_impl::_get_proc_address("glGetInfoLogARB","GL_ARB_shader_objects"));
	 fn(obj,maxLength,length,infoLog);
}

typedef void (*PFNGETATTACHEDOBJECTSARBPROC_HPP)(GLhandleARB containerObj,GLsizei maxCount,GLsizei *count,GLhandleARB *obj);

static inline void GetAttachedObjectsARB(GLhandleARB containerObj,GLsizei maxCount,GLsizei *count,GLhandleARB *obj)
{
	static PFNGETATTACHEDOBJECTSARBPROC_HPP fn=reinterpret_cast<PFNGETATTACHEDOBJECTSARBPROC_HPP>(_impl::_get_proc_address("glGetAttachedObjectsARB","GL_ARB_shader_objects"));
	 fn(containerObj,maxCount,count,obj);
}

typedef GLint (*PFNGETUNIFORMLOCATIONARBPROC_HPP)(GLhandleARB programObj,const GLcharARB *name);

static inline GLint GetUniformLocationARB(GLhandleARB programObj,const GLcharARB *name)
{
	static PFNGETUNIFORMLOCATIONARBPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMLOCATIONARBPROC_HPP>(_impl::_get_proc_address("glGetUniformLocationARB","GL_ARB_shader_objects"));
	return fn(programObj,name);
}

typedef void (*PFNGETACTIVEUNIFORMARBPROC_HPP)(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei *length,GLint *size,GLenum *type,GLcharARB *name);

static inline void GetActiveUniformARB(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei *length,GLint *size,GLenum *type,GLcharARB *name)
{
	static PFNGETACTIVEUNIFORMARBPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMARBPROC_HPP>(_impl::_get_proc_address("glGetActiveUniformARB","GL_ARB_shader_objects"));
	 fn(programObj,index,maxLength,length,size,type,name);
}

typedef void (*PFNGETUNIFORMFVARBPROC_HPP)(GLhandleARB programObj,GLint location,GLfloat *params);

static inline void GetUniformfvARB(GLhandleARB programObj,GLint location,GLfloat *params)
{
	static PFNGETUNIFORMFVARBPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMFVARBPROC_HPP>(_impl::_get_proc_address("glGetUniformfvARB","GL_ARB_shader_objects"));
	 fn(programObj,location,params);
}

typedef void (*PFNGETUNIFORMIVARBPROC_HPP)(GLhandleARB programObj,GLint location,GLint *params);

static inline void GetUniformivARB(GLhandleARB programObj,GLint location,GLint *params)
{
	static PFNGETUNIFORMIVARBPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMIVARBPROC_HPP>(_impl::_get_proc_address("glGetUniformivARB","GL_ARB_shader_objects"));
	 fn(programObj,location,params);
}

typedef void (*PFNGETSHADERSOURCEARBPROC_HPP)(GLhandleARB obj,GLsizei maxLength,GLsizei *length,GLcharARB *source);

static inline void GetShaderSourceARB(GLhandleARB obj,GLsizei maxLength,GLsizei *length,GLcharARB *source)
{
	static PFNGETSHADERSOURCEARBPROC_HPP fn=reinterpret_cast<PFNGETSHADERSOURCEARBPROC_HPP>(_impl::_get_proc_address("glGetShaderSourceARB","GL_ARB_shader_objects"));
	 fn(obj,maxLength,length,source);
}
#ifndef GL_ARB_shader_storage_buffer_object

#define GL_ARB_shader_storage_buffer_object
#ifndef GL_SHADER_STORAGE_BARRIER_BIT
#define GL_SHADER_STORAGE_BARRIER_BIT                                   0x00002000
#endif //GL_SHADER_STORAGE_BARRIER_BIT
#ifndef GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES
#define GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES                         0x8F39
#endif //GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES
#ifndef GL_SHADER_STORAGE_BUFFER
#define GL_SHADER_STORAGE_BUFFER                                        0x90D2
#endif //GL_SHADER_STORAGE_BUFFER
#ifndef GL_SHADER_STORAGE_BUFFER_BINDING
#define GL_SHADER_STORAGE_BUFFER_BINDING                                0x90D3
#endif //GL_SHADER_STORAGE_BUFFER_BINDING
#ifndef GL_SHADER_STORAGE_BUFFER_START
#define GL_SHADER_STORAGE_BUFFER_START                                  0x90D4
#endif //GL_SHADER_STORAGE_BUFFER_START
#ifndef GL_SHADER_STORAGE_BUFFER_SIZE
#define GL_SHADER_STORAGE_BUFFER_SIZE                                   0x90D5
#endif //GL_SHADER_STORAGE_BUFFER_SIZE
#ifndef GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS
#define GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS                             0x90D6
#endif //GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS
#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS                           0x90D7
#endif //GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS
#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS                       0x90D8
#endif //GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS
#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS                    0x90D9
#endif //GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS
#define GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS                           0x90DA
#endif //GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS
#define GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS                            0x90DB
#endif //GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS
#define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS                           0x90DC
#endif //GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS
#ifndef GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS
#define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS                           0x90DD
#endif //GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS
#ifndef GL_MAX_SHADER_STORAGE_BLOCK_SIZE
#define GL_MAX_SHADER_STORAGE_BLOCK_SIZE                                0x90DE
#endif //GL_MAX_SHADER_STORAGE_BLOCK_SIZE
#ifndef GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT
#define GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT                       0x90DF
#endif //GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT

#endif //GL_ARB_shader_storage_buffer_object


typedef void (*PFNSHADERSTORAGEBLOCKBINDINGPROC_HPP)(GLuint program,GLuint storageBlockIndex,GLuint storageBlockBinding);

static inline void ShaderStorageBlockBinding(GLuint program,GLuint storageBlockIndex,GLuint storageBlockBinding)
{
	static PFNSHADERSTORAGEBLOCKBINDINGPROC_HPP fn=reinterpret_cast<PFNSHADERSTORAGEBLOCKBINDINGPROC_HPP>(_impl::_get_proc_address("glShaderStorageBlockBinding","GL_ARB_shader_storage_buffer_object"));
	 fn(program,storageBlockIndex,storageBlockBinding);
}
#ifndef GL_ARB_shader_subroutine

#define GL_ARB_shader_subroutine
#ifndef GL_ACTIVE_SUBROUTINES
#define GL_ACTIVE_SUBROUTINES                                           0x8DE5
#endif //GL_ACTIVE_SUBROUTINES
#ifndef GL_ACTIVE_SUBROUTINE_UNIFORMS
#define GL_ACTIVE_SUBROUTINE_UNIFORMS                                   0x8DE6
#endif //GL_ACTIVE_SUBROUTINE_UNIFORMS
#ifndef GL_MAX_SUBROUTINES
#define GL_MAX_SUBROUTINES                                              0x8DE7
#endif //GL_MAX_SUBROUTINES
#ifndef GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS
#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS                             0x8DE8
#endif //GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS
#ifndef GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS                          0x8E47
#endif //GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
#ifndef GL_ACTIVE_SUBROUTINE_MAX_LENGTH
#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH                                 0x8E48
#endif //GL_ACTIVE_SUBROUTINE_MAX_LENGTH
#ifndef GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH                         0x8E49
#endif //GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
#ifndef GL_NUM_COMPATIBLE_SUBROUTINES
#define GL_NUM_COMPATIBLE_SUBROUTINES                                   0x8E4A
#endif //GL_NUM_COMPATIBLE_SUBROUTINES
#ifndef GL_COMPATIBLE_SUBROUTINES
#define GL_COMPATIBLE_SUBROUTINES                                       0x8E4B
#endif //GL_COMPATIBLE_SUBROUTINES

#endif //GL_ARB_shader_subroutine


typedef GLint (*PFNGETSUBROUTINEUNIFORMLOCATIONPROC_HPP)(GLuint program,GLenum shadertype,const GLchar *name);

static inline GLint GetSubroutineUniformLocation(GLuint program,GLenum shadertype,const GLchar *name)
{
	static PFNGETSUBROUTINEUNIFORMLOCATIONPROC_HPP fn=reinterpret_cast<PFNGETSUBROUTINEUNIFORMLOCATIONPROC_HPP>(_impl::_get_proc_address("glGetSubroutineUniformLocation","GL_ARB_shader_subroutine"));
	return fn(program,shadertype,name);
}

typedef GLuint (*PFNGETSUBROUTINEINDEXPROC_HPP)(GLuint program,GLenum shadertype,const GLchar *name);

static inline GLuint GetSubroutineIndex(GLuint program,GLenum shadertype,const GLchar *name)
{
	static PFNGETSUBROUTINEINDEXPROC_HPP fn=reinterpret_cast<PFNGETSUBROUTINEINDEXPROC_HPP>(_impl::_get_proc_address("glGetSubroutineIndex","GL_ARB_shader_subroutine"));
	return fn(program,shadertype,name);
}

typedef void (*PFNGETACTIVESUBROUTINEUNIFORMIVPROC_HPP)(GLuint program,GLenum shadertype,GLuint index,GLenum pname,GLint *values);

static inline void GetActiveSubroutineUniformiv(GLuint program,GLenum shadertype,GLuint index,GLenum pname,GLint *values)
{
	static PFNGETACTIVESUBROUTINEUNIFORMIVPROC_HPP fn=reinterpret_cast<PFNGETACTIVESUBROUTINEUNIFORMIVPROC_HPP>(_impl::_get_proc_address("glGetActiveSubroutineUniformiv","GL_ARB_shader_subroutine"));
	 fn(program,shadertype,index,pname,values);
}

typedef void (*PFNGETACTIVESUBROUTINEUNIFORMNAMEPROC_HPP)(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei *length,GLchar *name);

static inline void GetActiveSubroutineUniformName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei *length,GLchar *name)
{
	static PFNGETACTIVESUBROUTINEUNIFORMNAMEPROC_HPP fn=reinterpret_cast<PFNGETACTIVESUBROUTINEUNIFORMNAMEPROC_HPP>(_impl::_get_proc_address("glGetActiveSubroutineUniformName","GL_ARB_shader_subroutine"));
	 fn(program,shadertype,index,bufsize,length,name);
}

typedef void (*PFNGETACTIVESUBROUTINENAMEPROC_HPP)(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei *length,GLchar *name);

static inline void GetActiveSubroutineName(GLuint program,GLenum shadertype,GLuint index,GLsizei bufsize,GLsizei *length,GLchar *name)
{
	static PFNGETACTIVESUBROUTINENAMEPROC_HPP fn=reinterpret_cast<PFNGETACTIVESUBROUTINENAMEPROC_HPP>(_impl::_get_proc_address("glGetActiveSubroutineName","GL_ARB_shader_subroutine"));
	 fn(program,shadertype,index,bufsize,length,name);
}

typedef void (*PFNUNIFORMSUBROUTINESUIVPROC_HPP)(GLenum shadertype,GLsizei count,const GLuint *indices);

static inline void UniformSubroutinesuiv(GLenum shadertype,GLsizei count,const GLuint *indices)
{
	static PFNUNIFORMSUBROUTINESUIVPROC_HPP fn=reinterpret_cast<PFNUNIFORMSUBROUTINESUIVPROC_HPP>(_impl::_get_proc_address("glUniformSubroutinesuiv","GL_ARB_shader_subroutine"));
	 fn(shadertype,count,indices);
}

typedef void (*PFNGETUNIFORMSUBROUTINEUIVPROC_HPP)(GLenum shadertype,GLint location,GLuint *params);

static inline void GetUniformSubroutineuiv(GLenum shadertype,GLint location,GLuint *params)
{
	static PFNGETUNIFORMSUBROUTINEUIVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMSUBROUTINEUIVPROC_HPP>(_impl::_get_proc_address("glGetUniformSubroutineuiv","GL_ARB_shader_subroutine"));
	 fn(shadertype,location,params);
}

typedef void (*PFNGETPROGRAMSTAGEIVPROC_HPP)(GLuint program,GLenum shadertype,GLenum pname,GLint *values);

static inline void GetProgramStageiv(GLuint program,GLenum shadertype,GLenum pname,GLint *values)
{
	static PFNGETPROGRAMSTAGEIVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMSTAGEIVPROC_HPP>(_impl::_get_proc_address("glGetProgramStageiv","GL_ARB_shader_subroutine"));
	 fn(program,shadertype,pname,values);
}
#ifndef GL_ARB_shading_language_include

#define GL_ARB_shading_language_include
#ifndef GL_SHADER_INCLUDE_ARB
#define GL_SHADER_INCLUDE_ARB                                           0x8DAE
#endif //GL_SHADER_INCLUDE_ARB
#ifndef GL_NAMED_STRING_LENGTH_ARB
#define GL_NAMED_STRING_LENGTH_ARB                                      0x8DE9
#endif //GL_NAMED_STRING_LENGTH_ARB
#ifndef GL_NAMED_STRING_TYPE_ARB
#define GL_NAMED_STRING_TYPE_ARB                                        0x8DEA
#endif //GL_NAMED_STRING_TYPE_ARB

#endif //GL_ARB_shading_language_include


typedef void (*PFNNAMEDSTRINGARBPROC_HPP)(GLenum type,GLint namelen,const GLchar *name,GLint stringlen,const GLchar *string);

static inline void NamedStringARB(GLenum type,GLint namelen,const GLchar *name,GLint stringlen,const GLchar *string)
{
	static PFNNAMEDSTRINGARBPROC_HPP fn=reinterpret_cast<PFNNAMEDSTRINGARBPROC_HPP>(_impl::_get_proc_address("glNamedStringARB","GL_ARB_shading_language_include"));
	 fn(type,namelen,name,stringlen,string);
}

typedef void (*PFNDELETENAMEDSTRINGARBPROC_HPP)(GLint namelen,const GLchar *name);

static inline void DeleteNamedStringARB(GLint namelen,const GLchar *name)
{
	static PFNDELETENAMEDSTRINGARBPROC_HPP fn=reinterpret_cast<PFNDELETENAMEDSTRINGARBPROC_HPP>(_impl::_get_proc_address("glDeleteNamedStringARB","GL_ARB_shading_language_include"));
	 fn(namelen,name);
}

typedef void (*PFNCOMPILESHADERINCLUDEARBPROC_HPP)(GLuint shader,GLsizei count,const GLchar* *path,const GLint *length);

static inline void CompileShaderIncludeARB(GLuint shader,GLsizei count,const GLchar* *path,const GLint *length)
{
	static PFNCOMPILESHADERINCLUDEARBPROC_HPP fn=reinterpret_cast<PFNCOMPILESHADERINCLUDEARBPROC_HPP>(_impl::_get_proc_address("glCompileShaderIncludeARB","GL_ARB_shading_language_include"));
	 fn(shader,count,path,length);
}

typedef GLboolean (*PFNISNAMEDSTRINGARBPROC_HPP)(GLint namelen,const GLchar *name);

static inline GLboolean IsNamedStringARB(GLint namelen,const GLchar *name)
{
	static PFNISNAMEDSTRINGARBPROC_HPP fn=reinterpret_cast<PFNISNAMEDSTRINGARBPROC_HPP>(_impl::_get_proc_address("glIsNamedStringARB","GL_ARB_shading_language_include"));
	return fn(namelen,name);
}

typedef void (*PFNGETNAMEDSTRINGARBPROC_HPP)(GLint namelen,const GLchar *name,GLsizei bufSize,GLint *stringlen,GLchar *string);

static inline void GetNamedStringARB(GLint namelen,const GLchar *name,GLsizei bufSize,GLint *stringlen,GLchar *string)
{
	static PFNGETNAMEDSTRINGARBPROC_HPP fn=reinterpret_cast<PFNGETNAMEDSTRINGARBPROC_HPP>(_impl::_get_proc_address("glGetNamedStringARB","GL_ARB_shading_language_include"));
	 fn(namelen,name,bufSize,stringlen,string);
}

typedef void (*PFNGETNAMEDSTRINGIVARBPROC_HPP)(GLint namelen,const GLchar *name,GLenum pname,GLint *params);

static inline void GetNamedStringivARB(GLint namelen,const GLchar *name,GLenum pname,GLint *params)
{
	static PFNGETNAMEDSTRINGIVARBPROC_HPP fn=reinterpret_cast<PFNGETNAMEDSTRINGIVARBPROC_HPP>(_impl::_get_proc_address("glGetNamedStringivARB","GL_ARB_shading_language_include"));
	 fn(namelen,name,pname,params);
}
#ifndef GL_ARB_shadow

#define GL_ARB_shadow
#ifndef GL_TEXTURE_COMPARE_MODE_ARB
#define GL_TEXTURE_COMPARE_MODE_ARB                                     0x884C
#endif //GL_TEXTURE_COMPARE_MODE_ARB
#ifndef GL_TEXTURE_COMPARE_FUNC_ARB
#define GL_TEXTURE_COMPARE_FUNC_ARB                                     0x884D
#endif //GL_TEXTURE_COMPARE_FUNC_ARB

#endif //GL_ARB_shadow

#ifndef GL_ARB_stencil_texturing

#define GL_ARB_stencil_texturing
#ifndef GL_DEPTH_STENCIL_TEXTURE_MODE
#define GL_DEPTH_STENCIL_TEXTURE_MODE                                   0x90EA
#endif //GL_DEPTH_STENCIL_TEXTURE_MODE

#endif //GL_ARB_stencil_texturing

#ifndef GL_ARB_sync

#define GL_ARB_sync

#endif //GL_ARB_sync


typedef GLsync (*PFNFENCESYNCPROC_HPP)(GLenum condition,GLbitfield flags);

static inline GLsync FenceSync(GLenum condition,GLbitfield flags)
{
	static PFNFENCESYNCPROC_HPP fn=reinterpret_cast<PFNFENCESYNCPROC_HPP>(_impl::_get_proc_address("glFenceSync","GL_ARB_sync"));
	return fn(condition,flags);
}

typedef GLboolean (*PFNISSYNCPROC_HPP)(GLsync sync);

static inline GLboolean IsSync(GLsync sync)
{
	static PFNISSYNCPROC_HPP fn=reinterpret_cast<PFNISSYNCPROC_HPP>(_impl::_get_proc_address("glIsSync","GL_ARB_sync"));
	return fn(sync);
}

typedef void (*PFNDELETESYNCPROC_HPP)(GLsync sync);

static inline void DeleteSync(GLsync sync)
{
	static PFNDELETESYNCPROC_HPP fn=reinterpret_cast<PFNDELETESYNCPROC_HPP>(_impl::_get_proc_address("glDeleteSync","GL_ARB_sync"));
	 fn(sync);
}

typedef GLenum (*PFNCLIENTWAITSYNCPROC_HPP)(GLsync sync,GLbitfield flags,GLuint64 timeout);

static inline GLenum ClientWaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout)
{
	static PFNCLIENTWAITSYNCPROC_HPP fn=reinterpret_cast<PFNCLIENTWAITSYNCPROC_HPP>(_impl::_get_proc_address("glClientWaitSync","GL_ARB_sync"));
	return fn(sync,flags,timeout);
}

typedef void (*PFNWAITSYNCPROC_HPP)(GLsync sync,GLbitfield flags,GLuint64 timeout);

static inline void WaitSync(GLsync sync,GLbitfield flags,GLuint64 timeout)
{
	static PFNWAITSYNCPROC_HPP fn=reinterpret_cast<PFNWAITSYNCPROC_HPP>(_impl::_get_proc_address("glWaitSync","GL_ARB_sync"));
	 fn(sync,flags,timeout);
}

typedef void (*PFNGETINTEGER64VPROC_HPP)(GLenum pname,GLint64 *params);

static inline void GetInteger64v(GLenum pname,GLint64 *params)
{
	static PFNGETINTEGER64VPROC_HPP fn=reinterpret_cast<PFNGETINTEGER64VPROC_HPP>(_impl::_get_proc_address("glGetInteger64v","GL_ARB_sync"));
	 fn(pname,params);
}

typedef void (*PFNGETSYNCIVPROC_HPP)(GLsync sync,GLenum pname,GLsizei bufSize,GLsizei *length,GLint *values);

static inline void GetSynciv(GLsync sync,GLenum pname,GLsizei bufSize,GLsizei *length,GLint *values)
{
	static PFNGETSYNCIVPROC_HPP fn=reinterpret_cast<PFNGETSYNCIVPROC_HPP>(_impl::_get_proc_address("glGetSynciv","GL_ARB_sync"));
	 fn(sync,pname,bufSize,length,values);
}
#ifndef GL_ARB_tessellation_shader

#define GL_ARB_tessellation_shader
#ifndef GL_PATCHES
#define GL_PATCHES                                                      0x000E
#endif //GL_PATCHES
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER              0x84F0
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER
#ifndef GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER
#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER           0x84F1
#endif //GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER
#ifndef GL_MAX_TESS_CONTROL_INPUT_COMPONENTS
#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS                            0x886C
#endif //GL_MAX_TESS_CONTROL_INPUT_COMPONENTS
#ifndef GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS
#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS                         0x886D
#endif //GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS
#ifndef GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS                 0x8E1E
#endif //GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS
#ifndef GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS
#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS              0x8E1F
#endif //GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS
#ifndef GL_PATCH_VERTICES
#define GL_PATCH_VERTICES                                               0x8E72
#endif //GL_PATCH_VERTICES
#ifndef GL_PATCH_DEFAULT_INNER_LEVEL
#define GL_PATCH_DEFAULT_INNER_LEVEL                                    0x8E73
#endif //GL_PATCH_DEFAULT_INNER_LEVEL
#ifndef GL_PATCH_DEFAULT_OUTER_LEVEL
#define GL_PATCH_DEFAULT_OUTER_LEVEL                                    0x8E74
#endif //GL_PATCH_DEFAULT_OUTER_LEVEL
#ifndef GL_TESS_CONTROL_OUTPUT_VERTICES
#define GL_TESS_CONTROL_OUTPUT_VERTICES                                 0x8E75
#endif //GL_TESS_CONTROL_OUTPUT_VERTICES
#ifndef GL_TESS_GEN_MODE
#define GL_TESS_GEN_MODE                                                0x8E76
#endif //GL_TESS_GEN_MODE
#ifndef GL_TESS_GEN_SPACING
#define GL_TESS_GEN_SPACING                                             0x8E77
#endif //GL_TESS_GEN_SPACING
#ifndef GL_TESS_GEN_VERTEX_ORDER
#define GL_TESS_GEN_VERTEX_ORDER                                        0x8E78
#endif //GL_TESS_GEN_VERTEX_ORDER
#ifndef GL_TESS_GEN_POINT_MODE
#define GL_TESS_GEN_POINT_MODE                                          0x8E79
#endif //GL_TESS_GEN_POINT_MODE
#ifndef GL_ISOLINES
#define GL_ISOLINES                                                     0x8E7A
#endif //GL_ISOLINES
#ifndef GL_FRACTIONAL_ODD
#define GL_FRACTIONAL_ODD                                               0x8E7B
#endif //GL_FRACTIONAL_ODD
#ifndef GL_FRACTIONAL_EVEN
#define GL_FRACTIONAL_EVEN                                              0x8E7C
#endif //GL_FRACTIONAL_EVEN
#ifndef GL_MAX_PATCH_VERTICES
#define GL_MAX_PATCH_VERTICES                                           0x8E7D
#endif //GL_MAX_PATCH_VERTICES
#ifndef GL_MAX_TESS_GEN_LEVEL
#define GL_MAX_TESS_GEN_LEVEL                                           0x8E7E
#endif //GL_MAX_TESS_GEN_LEVEL
#ifndef GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS
#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS                          0x8E7F
#endif //GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS
#ifndef GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS
#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS                       0x8E80
#endif //GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS
#ifndef GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS
#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS                         0x8E81
#endif //GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS
#ifndef GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS
#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS                      0x8E82
#endif //GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS
#ifndef GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS
#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS                           0x8E83
#endif //GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS
#ifndef GL_MAX_TESS_PATCH_COMPONENTS
#define GL_MAX_TESS_PATCH_COMPONENTS                                    0x8E84
#endif //GL_MAX_TESS_PATCH_COMPONENTS
#ifndef GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS
#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS                     0x8E85
#endif //GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS
#ifndef GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS
#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS                        0x8E86
#endif //GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS
#ifndef GL_TESS_EVALUATION_SHADER
#define GL_TESS_EVALUATION_SHADER                                       0x8E87
#endif //GL_TESS_EVALUATION_SHADER
#ifndef GL_TESS_CONTROL_SHADER
#define GL_TESS_CONTROL_SHADER                                          0x8E88
#endif //GL_TESS_CONTROL_SHADER
#ifndef GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS
#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS                              0x8E89
#endif //GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS
#ifndef GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS
#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS                           0x8E8A
#endif //GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS

#endif //GL_ARB_tessellation_shader


typedef void (*PFNPATCHPARAMETERIPROC_HPP)(GLenum pname,GLint value);

static inline void PatchParameteri(GLenum pname,GLint value)
{
	static PFNPATCHPARAMETERIPROC_HPP fn=reinterpret_cast<PFNPATCHPARAMETERIPROC_HPP>(_impl::_get_proc_address("glPatchParameteri","GL_ARB_tessellation_shader"));
	 fn(pname,value);
}

typedef void (*PFNPATCHPARAMETERFVPROC_HPP)(GLenum pname,const GLfloat *values);

static inline void PatchParameterfv(GLenum pname,const GLfloat *values)
{
	static PFNPATCHPARAMETERFVPROC_HPP fn=reinterpret_cast<PFNPATCHPARAMETERFVPROC_HPP>(_impl::_get_proc_address("glPatchParameterfv","GL_ARB_tessellation_shader"));
	 fn(pname,values);
}
#ifndef GL_ARB_texture_border_clamp

#define GL_ARB_texture_border_clamp
#ifndef GL_CLAMP_TO_BORDER_ARB
#define GL_CLAMP_TO_BORDER_ARB                                          0x812D
#endif //GL_CLAMP_TO_BORDER_ARB

#endif //GL_ARB_texture_border_clamp

#ifndef GL_ARB_texture_buffer_object

#define GL_ARB_texture_buffer_object
#ifndef GL_TEXTURE_BUFFER_ARB
#define GL_TEXTURE_BUFFER_ARB                                           0x8C2A
#endif //GL_TEXTURE_BUFFER_ARB
#ifndef GL_MAX_TEXTURE_BUFFER_SIZE_ARB
#define GL_MAX_TEXTURE_BUFFER_SIZE_ARB                                  0x8C2B
#endif //GL_MAX_TEXTURE_BUFFER_SIZE_ARB
#ifndef GL_TEXTURE_BINDING_BUFFER_ARB
#define GL_TEXTURE_BINDING_BUFFER_ARB                                   0x8C2C
#endif //GL_TEXTURE_BINDING_BUFFER_ARB
#ifndef GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB
#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB                        0x8C2D
#endif //GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB
#ifndef GL_TEXTURE_BUFFER_FORMAT_ARB
#define GL_TEXTURE_BUFFER_FORMAT_ARB                                    0x8C2E
#endif //GL_TEXTURE_BUFFER_FORMAT_ARB

#endif //GL_ARB_texture_buffer_object


typedef void (*PFNTEXBUFFERARBPROC_HPP)(GLenum target,GLenum internalformat,GLuint buffer);

static inline void TexBufferARB(GLenum target,GLenum internalformat,GLuint buffer)
{
	static PFNTEXBUFFERARBPROC_HPP fn=reinterpret_cast<PFNTEXBUFFERARBPROC_HPP>(_impl::_get_proc_address("glTexBufferARB","GL_ARB_texture_buffer_object"));
	 fn(target,internalformat,buffer);
}
#ifndef GL_ARB_texture_buffer_range

#define GL_ARB_texture_buffer_range
#ifndef GL_TEXTURE_BUFFER_OFFSET
#define GL_TEXTURE_BUFFER_OFFSET                                        0x919D
#endif //GL_TEXTURE_BUFFER_OFFSET
#ifndef GL_TEXTURE_BUFFER_SIZE
#define GL_TEXTURE_BUFFER_SIZE                                          0x919E
#endif //GL_TEXTURE_BUFFER_SIZE
#ifndef GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT
#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT                              0x919F
#endif //GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT

#endif //GL_ARB_texture_buffer_range


typedef void (*PFNTEXBUFFERRANGEPROC_HPP)(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size);

static inline void TexBufferRange(GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)
{
	static PFNTEXBUFFERRANGEPROC_HPP fn=reinterpret_cast<PFNTEXBUFFERRANGEPROC_HPP>(_impl::_get_proc_address("glTexBufferRange","GL_ARB_texture_buffer_range"));
	 fn(target,internalformat,buffer,offset,size);
}

typedef void (*PFNTEXTUREBUFFERRANGEEXTPROC_HPP)(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size);

static inline void TextureBufferRangeEXT(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer,GLintptr offset,GLsizeiptr size)
{
	static PFNTEXTUREBUFFERRANGEEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREBUFFERRANGEEXTPROC_HPP>(_impl::_get_proc_address("glTextureBufferRangeEXT","GL_ARB_texture_buffer_range"));
	 fn(texture,target,internalformat,buffer,offset,size);
}
#ifndef GL_ARB_texture_compression

#define GL_ARB_texture_compression
#ifndef GL_COMPRESSED_ALPHA_ARB
#define GL_COMPRESSED_ALPHA_ARB                                         0x84E9
#endif //GL_COMPRESSED_ALPHA_ARB
#ifndef GL_COMPRESSED_LUMINANCE_ARB
#define GL_COMPRESSED_LUMINANCE_ARB                                     0x84EA
#endif //GL_COMPRESSED_LUMINANCE_ARB
#ifndef GL_COMPRESSED_LUMINANCE_ALPHA_ARB
#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB                               0x84EB
#endif //GL_COMPRESSED_LUMINANCE_ALPHA_ARB
#ifndef GL_COMPRESSED_INTENSITY_ARB
#define GL_COMPRESSED_INTENSITY_ARB                                     0x84EC
#endif //GL_COMPRESSED_INTENSITY_ARB
#ifndef GL_COMPRESSED_RGB_ARB
#define GL_COMPRESSED_RGB_ARB                                           0x84ED
#endif //GL_COMPRESSED_RGB_ARB
#ifndef GL_COMPRESSED_RGBA_ARB
#define GL_COMPRESSED_RGBA_ARB                                          0x84EE
#endif //GL_COMPRESSED_RGBA_ARB
#ifndef GL_TEXTURE_COMPRESSION_HINT_ARB
#define GL_TEXTURE_COMPRESSION_HINT_ARB                                 0x84EF
#endif //GL_TEXTURE_COMPRESSION_HINT_ARB
#ifndef GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB
#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB                            0x86A0
#endif //GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB
#ifndef GL_TEXTURE_COMPRESSED_ARB
#define GL_TEXTURE_COMPRESSED_ARB                                       0x86A1
#endif //GL_TEXTURE_COMPRESSED_ARB
#ifndef GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB                           0x86A2
#endif //GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB
#ifndef GL_COMPRESSED_TEXTURE_FORMATS_ARB
#define GL_COMPRESSED_TEXTURE_FORMATS_ARB                               0x86A3
#endif //GL_COMPRESSED_TEXTURE_FORMATS_ARB

#endif //GL_ARB_texture_compression


typedef void (*PFNCOMPRESSEDTEXIMAGE3DARBPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage3DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE3DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE3DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage3DARB","GL_ARB_texture_compression"));
	 fn(target,level,internalformat,width,height,depth,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXIMAGE2DARBPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage2DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE2DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE2DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage2DARB","GL_ARB_texture_compression"));
	 fn(target,level,internalformat,width,height,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXIMAGE1DARBPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexImage1DARB(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXIMAGE1DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXIMAGE1DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexImage1DARB","GL_ARB_texture_compression"));
	 fn(target,level,internalformat,width,border,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE3DARBPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage3DARB(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE3DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE3DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage3DARB","GL_ARB_texture_compression"));
	 fn(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE2DARBPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage2DARB(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE2DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE2DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage2DARB","GL_ARB_texture_compression"));
	 fn(target,level,xoffset,yoffset,width,height,format,imageSize,data);
}

typedef void (*PFNCOMPRESSEDTEXSUBIMAGE1DARBPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *data);

static inline void CompressedTexSubImage1DARB(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *data)
{
	static PFNCOMPRESSEDTEXSUBIMAGE1DARBPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXSUBIMAGE1DARBPROC_HPP>(_impl::_get_proc_address("glCompressedTexSubImage1DARB","GL_ARB_texture_compression"));
	 fn(target,level,xoffset,width,format,imageSize,data);
}

typedef void (*PFNGETCOMPRESSEDTEXIMAGEARBPROC_HPP)(GLenum target,GLint level,GLvoid *img);

static inline void GetCompressedTexImageARB(GLenum target,GLint level,GLvoid *img)
{
	static PFNGETCOMPRESSEDTEXIMAGEARBPROC_HPP fn=reinterpret_cast<PFNGETCOMPRESSEDTEXIMAGEARBPROC_HPP>(_impl::_get_proc_address("glGetCompressedTexImageARB","GL_ARB_texture_compression"));
	 fn(target,level,img);
}
#ifndef GL_ARB_texture_compression_bptc

#define GL_ARB_texture_compression_bptc
#ifndef GL_COMPRESSED_RGBA_BPTC_UNORM_ARB
#define GL_COMPRESSED_RGBA_BPTC_UNORM_ARB                               0x8E8C
#endif //GL_COMPRESSED_RGBA_BPTC_UNORM_ARB
#ifndef GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB
#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB                         0x8E8D
#endif //GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB
#ifndef GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB
#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB                         0x8E8E
#endif //GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB
#ifndef GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB
#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB                       0x8E8F
#endif //GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB

#endif //GL_ARB_texture_compression_bptc

#ifndef GL_ARB_texture_compression_rgtc

#define GL_ARB_texture_compression_rgtc
#ifndef GL_COMPRESSED_RED_RGTC1
#define GL_COMPRESSED_RED_RGTC1                                         0x8DBB
#endif //GL_COMPRESSED_RED_RGTC1
#ifndef GL_COMPRESSED_SIGNED_RED_RGTC1
#define GL_COMPRESSED_SIGNED_RED_RGTC1                                  0x8DBC
#endif //GL_COMPRESSED_SIGNED_RED_RGTC1
#ifndef GL_COMPRESSED_RG_RGTC2
#define GL_COMPRESSED_RG_RGTC2                                          0x8DBD
#endif //GL_COMPRESSED_RG_RGTC2
#ifndef GL_COMPRESSED_SIGNED_RG_RGTC2
#define GL_COMPRESSED_SIGNED_RG_RGTC2                                   0x8DBE
#endif //GL_COMPRESSED_SIGNED_RG_RGTC2

#endif //GL_ARB_texture_compression_rgtc

#ifndef GL_ARB_texture_cube_map

#define GL_ARB_texture_cube_map
#ifndef GL_NORMAL_MAP_ARB
#define GL_NORMAL_MAP_ARB                                               0x8511
#endif //GL_NORMAL_MAP_ARB
#ifndef GL_REFLECTION_MAP_ARB
#define GL_REFLECTION_MAP_ARB                                           0x8512
#endif //GL_REFLECTION_MAP_ARB
#ifndef GL_TEXTURE_CUBE_MAP_ARB
#define GL_TEXTURE_CUBE_MAP_ARB                                         0x8513
#endif //GL_TEXTURE_CUBE_MAP_ARB
#ifndef GL_TEXTURE_BINDING_CUBE_MAP_ARB
#define GL_TEXTURE_BINDING_CUBE_MAP_ARB                                 0x8514
#endif //GL_TEXTURE_BINDING_CUBE_MAP_ARB
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                              0x8515
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                              0x8516
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                              0x8517
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                              0x8518
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                              0x8519
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                              0x851A
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
#ifndef GL_PROXY_TEXTURE_CUBE_MAP_ARB
#define GL_PROXY_TEXTURE_CUBE_MAP_ARB                                   0x851B
#endif //GL_PROXY_TEXTURE_CUBE_MAP_ARB
#ifndef GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB
#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB                                0x851C
#endif //GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB

#endif //GL_ARB_texture_cube_map

#ifndef GL_ARB_texture_cube_map_array

#define GL_ARB_texture_cube_map_array
#ifndef GL_TEXTURE_CUBE_MAP_ARRAY
#define GL_TEXTURE_CUBE_MAP_ARRAY                                       0x9009
#endif //GL_TEXTURE_CUBE_MAP_ARRAY
#ifndef GL_TEXTURE_BINDING_CUBE_MAP_ARRAY
#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY                               0x900A
#endif //GL_TEXTURE_BINDING_CUBE_MAP_ARRAY
#ifndef GL_PROXY_TEXTURE_CUBE_MAP_ARRAY
#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY                                 0x900B
#endif //GL_PROXY_TEXTURE_CUBE_MAP_ARRAY
#ifndef GL_SAMPLER_CUBE_MAP_ARRAY
#define GL_SAMPLER_CUBE_MAP_ARRAY                                       0x900C
#endif //GL_SAMPLER_CUBE_MAP_ARRAY
#ifndef GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW
#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW                                0x900D
#endif //GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW
#ifndef GL_INT_SAMPLER_CUBE_MAP_ARRAY
#define GL_INT_SAMPLER_CUBE_MAP_ARRAY                                   0x900E
#endif //GL_INT_SAMPLER_CUBE_MAP_ARRAY
#ifndef GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY
#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY                          0x900F
#endif //GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY

#endif //GL_ARB_texture_cube_map_array

#ifndef GL_ARB_texture_env_combine

#define GL_ARB_texture_env_combine
#ifndef GL_SUBTRACT_ARB
#define GL_SUBTRACT_ARB                                                 0x84E7
#endif //GL_SUBTRACT_ARB

#endif //GL_ARB_texture_env_combine

#ifndef GL_ARB_texture_env_dot3

#define GL_ARB_texture_env_dot3
#ifndef GL_DOT3_RGB_ARB
#define GL_DOT3_RGB_ARB                                                 0x86AE
#endif //GL_DOT3_RGB_ARB
#ifndef GL_DOT3_RGBA_ARB
#define GL_DOT3_RGBA_ARB                                                0x86AF
#endif //GL_DOT3_RGBA_ARB

#endif //GL_ARB_texture_env_dot3

#ifndef GL_ARB_texture_float

#define GL_ARB_texture_float
#ifndef GL_RGBA32F_ARB
#define GL_RGBA32F_ARB                                                  0x8814
#endif //GL_RGBA32F_ARB
#ifndef GL_RGB32F_ARB
#define GL_RGB32F_ARB                                                   0x8815
#endif //GL_RGB32F_ARB
#ifndef GL_ALPHA32F_ARB
#define GL_ALPHA32F_ARB                                                 0x8816
#endif //GL_ALPHA32F_ARB
#ifndef GL_INTENSITY32F_ARB
#define GL_INTENSITY32F_ARB                                             0x8817
#endif //GL_INTENSITY32F_ARB
#ifndef GL_LUMINANCE32F_ARB
#define GL_LUMINANCE32F_ARB                                             0x8818
#endif //GL_LUMINANCE32F_ARB
#ifndef GL_LUMINANCE_ALPHA32F_ARB
#define GL_LUMINANCE_ALPHA32F_ARB                                       0x8819
#endif //GL_LUMINANCE_ALPHA32F_ARB
#ifndef GL_RGBA16F_ARB
#define GL_RGBA16F_ARB                                                  0x881A
#endif //GL_RGBA16F_ARB
#ifndef GL_RGB16F_ARB
#define GL_RGB16F_ARB                                                   0x881B
#endif //GL_RGB16F_ARB
#ifndef GL_ALPHA16F_ARB
#define GL_ALPHA16F_ARB                                                 0x881C
#endif //GL_ALPHA16F_ARB
#ifndef GL_INTENSITY16F_ARB
#define GL_INTENSITY16F_ARB                                             0x881D
#endif //GL_INTENSITY16F_ARB
#ifndef GL_LUMINANCE16F_ARB
#define GL_LUMINANCE16F_ARB                                             0x881E
#endif //GL_LUMINANCE16F_ARB
#ifndef GL_LUMINANCE_ALPHA16F_ARB
#define GL_LUMINANCE_ALPHA16F_ARB                                       0x881F
#endif //GL_LUMINANCE_ALPHA16F_ARB
#ifndef GL_TEXTURE_RED_TYPE_ARB
#define GL_TEXTURE_RED_TYPE_ARB                                         0x8C10
#endif //GL_TEXTURE_RED_TYPE_ARB
#ifndef GL_TEXTURE_GREEN_TYPE_ARB
#define GL_TEXTURE_GREEN_TYPE_ARB                                       0x8C11
#endif //GL_TEXTURE_GREEN_TYPE_ARB
#ifndef GL_TEXTURE_BLUE_TYPE_ARB
#define GL_TEXTURE_BLUE_TYPE_ARB                                        0x8C12
#endif //GL_TEXTURE_BLUE_TYPE_ARB
#ifndef GL_TEXTURE_ALPHA_TYPE_ARB
#define GL_TEXTURE_ALPHA_TYPE_ARB                                       0x8C13
#endif //GL_TEXTURE_ALPHA_TYPE_ARB
#ifndef GL_TEXTURE_LUMINANCE_TYPE_ARB
#define GL_TEXTURE_LUMINANCE_TYPE_ARB                                   0x8C14
#endif //GL_TEXTURE_LUMINANCE_TYPE_ARB
#ifndef GL_TEXTURE_INTENSITY_TYPE_ARB
#define GL_TEXTURE_INTENSITY_TYPE_ARB                                   0x8C15
#endif //GL_TEXTURE_INTENSITY_TYPE_ARB
#ifndef GL_TEXTURE_DEPTH_TYPE_ARB
#define GL_TEXTURE_DEPTH_TYPE_ARB                                       0x8C16
#endif //GL_TEXTURE_DEPTH_TYPE_ARB
#ifndef GL_UNSIGNED_NORMALIZED_ARB
#define GL_UNSIGNED_NORMALIZED_ARB                                      0x8C17
#endif //GL_UNSIGNED_NORMALIZED_ARB

#endif //GL_ARB_texture_float

#ifndef GL_ARB_texture_gather

#define GL_ARB_texture_gather
#ifndef GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB
#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB                        0x8E5E
#endif //GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB
#ifndef GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB
#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB                        0x8E5F
#endif //GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB
#ifndef GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB
#define GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB                    0x8F9F
#endif //GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB

#endif //GL_ARB_texture_gather

#ifndef GL_ARB_texture_mirrored_repeat

#define GL_ARB_texture_mirrored_repeat
#ifndef GL_MIRRORED_REPEAT_ARB
#define GL_MIRRORED_REPEAT_ARB                                          0x8370
#endif //GL_MIRRORED_REPEAT_ARB

#endif //GL_ARB_texture_mirrored_repeat

#ifndef GL_ARB_texture_multisample

#define GL_ARB_texture_multisample

#endif //GL_ARB_texture_multisample


typedef void (*PFNTEXIMAGE2DMULTISAMPLEPROC_HPP)(GLenum target,GLsizei samples,GLint internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);

static inline void TexImage2DMultisample(GLenum target,GLsizei samples,GLint internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)
{
	static PFNTEXIMAGE2DMULTISAMPLEPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE2DMULTISAMPLEPROC_HPP>(_impl::_get_proc_address("glTexImage2DMultisample","GL_ARB_texture_multisample"));
	 fn(target,samples,internalformat,width,height,fixedsamplelocations);
}

typedef void (*PFNTEXIMAGE3DMULTISAMPLEPROC_HPP)(GLenum target,GLsizei samples,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);

static inline void TexImage3DMultisample(GLenum target,GLsizei samples,GLint internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)
{
	static PFNTEXIMAGE3DMULTISAMPLEPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE3DMULTISAMPLEPROC_HPP>(_impl::_get_proc_address("glTexImage3DMultisample","GL_ARB_texture_multisample"));
	 fn(target,samples,internalformat,width,height,depth,fixedsamplelocations);
}

typedef void (*PFNGETMULTISAMPLEFVPROC_HPP)(GLenum pname,GLuint index,GLfloat *val);

static inline void GetMultisamplefv(GLenum pname,GLuint index,GLfloat *val)
{
	static PFNGETMULTISAMPLEFVPROC_HPP fn=reinterpret_cast<PFNGETMULTISAMPLEFVPROC_HPP>(_impl::_get_proc_address("glGetMultisamplefv","GL_ARB_texture_multisample"));
	 fn(pname,index,val);
}

typedef void (*PFNSAMPLEMASKIPROC_HPP)(GLuint index,GLbitfield mask);

static inline void SampleMaski(GLuint index,GLbitfield mask)
{
	static PFNSAMPLEMASKIPROC_HPP fn=reinterpret_cast<PFNSAMPLEMASKIPROC_HPP>(_impl::_get_proc_address("glSampleMaski","GL_ARB_texture_multisample"));
	 fn(index,mask);
}
#ifndef GL_ARB_texture_rectangle

#define GL_ARB_texture_rectangle
#ifndef GL_TEXTURE_RECTANGLE_ARB
#define GL_TEXTURE_RECTANGLE_ARB                                        0x84F5
#endif //GL_TEXTURE_RECTANGLE_ARB
#ifndef GL_TEXTURE_BINDING_RECTANGLE_ARB
#define GL_TEXTURE_BINDING_RECTANGLE_ARB                                0x84F6
#endif //GL_TEXTURE_BINDING_RECTANGLE_ARB
#ifndef GL_PROXY_TEXTURE_RECTANGLE_ARB
#define GL_PROXY_TEXTURE_RECTANGLE_ARB                                  0x84F7
#endif //GL_PROXY_TEXTURE_RECTANGLE_ARB
#ifndef GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB
#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB                               0x84F8
#endif //GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB

#endif //GL_ARB_texture_rectangle

#ifndef GL_ARB_texture_rg

#define GL_ARB_texture_rg

#endif //GL_ARB_texture_rg

#ifndef GL_ARB_texture_rgb10_a2ui

#define GL_ARB_texture_rgb10_a2ui
#ifndef GL_RGB10_A2UI
#define GL_RGB10_A2UI                                                   0x906F
#endif //GL_RGB10_A2UI

#endif //GL_ARB_texture_rgb10_a2ui

#ifndef GL_ARB_texture_storage

#define GL_ARB_texture_storage
#ifndef GL_TEXTURE_IMMUTABLE_FORMAT
#define GL_TEXTURE_IMMUTABLE_FORMAT                                     0x912F
#endif //GL_TEXTURE_IMMUTABLE_FORMAT

#endif //GL_ARB_texture_storage


typedef void (*PFNTEXSTORAGE1DPROC_HPP)(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width);

static inline void TexStorage1D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)
{
	static PFNTEXSTORAGE1DPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGE1DPROC_HPP>(_impl::_get_proc_address("glTexStorage1D","GL_ARB_texture_storage"));
	 fn(target,levels,internalformat,width);
}

typedef void (*PFNTEXSTORAGE2DPROC_HPP)(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height);

static inline void TexStorage2D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNTEXSTORAGE2DPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGE2DPROC_HPP>(_impl::_get_proc_address("glTexStorage2D","GL_ARB_texture_storage"));
	 fn(target,levels,internalformat,width,height);
}

typedef void (*PFNTEXSTORAGE3DPROC_HPP)(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);

static inline void TexStorage3D(GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)
{
	static PFNTEXSTORAGE3DPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGE3DPROC_HPP>(_impl::_get_proc_address("glTexStorage3D","GL_ARB_texture_storage"));
	 fn(target,levels,internalformat,width,height,depth);
}

typedef void (*PFNTEXTURESTORAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width);

static inline void TextureStorage1DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width)
{
	static PFNTEXTURESTORAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glTextureStorage1DEXT","GL_ARB_texture_storage"));
	 fn(texture,target,levels,internalformat,width);
}

typedef void (*PFNTEXTURESTORAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height);

static inline void TextureStorage2DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNTEXTURESTORAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glTextureStorage2DEXT","GL_ARB_texture_storage"));
	 fn(texture,target,levels,internalformat,width,height);
}

typedef void (*PFNTEXTURESTORAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth);

static inline void TextureStorage3DEXT(GLuint texture,GLenum target,GLsizei levels,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth)
{
	static PFNTEXTURESTORAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glTextureStorage3DEXT","GL_ARB_texture_storage"));
	 fn(texture,target,levels,internalformat,width,height,depth);
}
#ifndef GL_ARB_texture_storage_multisample

#define GL_ARB_texture_storage_multisample

#endif //GL_ARB_texture_storage_multisample


typedef void (*PFNTEXSTORAGE2DMULTISAMPLEPROC_HPP)(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);

static inline void TexStorage2DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)
{
	static PFNTEXSTORAGE2DMULTISAMPLEPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGE2DMULTISAMPLEPROC_HPP>(_impl::_get_proc_address("glTexStorage2DMultisample","GL_ARB_texture_storage_multisample"));
	 fn(target,samples,internalformat,width,height,fixedsamplelocations);
}

typedef void (*PFNTEXSTORAGE3DMULTISAMPLEPROC_HPP)(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);

static inline void TexStorage3DMultisample(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)
{
	static PFNTEXSTORAGE3DMULTISAMPLEPROC_HPP fn=reinterpret_cast<PFNTEXSTORAGE3DMULTISAMPLEPROC_HPP>(_impl::_get_proc_address("glTexStorage3DMultisample","GL_ARB_texture_storage_multisample"));
	 fn(target,samples,internalformat,width,height,depth,fixedsamplelocations);
}

typedef void (*PFNTEXTURESTORAGE2DMULTISAMPLEEXTPROC_HPP)(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations);

static inline void TextureStorage2DMultisampleEXT(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLboolean fixedsamplelocations)
{
	static PFNTEXTURESTORAGE2DMULTISAMPLEEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGE2DMULTISAMPLEEXTPROC_HPP>(_impl::_get_proc_address("glTextureStorage2DMultisampleEXT","GL_ARB_texture_storage_multisample"));
	 fn(texture,target,samples,internalformat,width,height,fixedsamplelocations);
}

typedef void (*PFNTEXTURESTORAGE3DMULTISAMPLEEXTPROC_HPP)(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations);

static inline void TextureStorage3DMultisampleEXT(GLuint texture,GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedsamplelocations)
{
	static PFNTEXTURESTORAGE3DMULTISAMPLEEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESTORAGE3DMULTISAMPLEEXTPROC_HPP>(_impl::_get_proc_address("glTextureStorage3DMultisampleEXT","GL_ARB_texture_storage_multisample"));
	 fn(texture,target,samples,internalformat,width,height,depth,fixedsamplelocations);
}
#ifndef GL_ARB_texture_swizzle

#define GL_ARB_texture_swizzle
#ifndef GL_TEXTURE_SWIZZLE_R
#define GL_TEXTURE_SWIZZLE_R                                            0x8E42
#endif //GL_TEXTURE_SWIZZLE_R
#ifndef GL_TEXTURE_SWIZZLE_G
#define GL_TEXTURE_SWIZZLE_G                                            0x8E43
#endif //GL_TEXTURE_SWIZZLE_G
#ifndef GL_TEXTURE_SWIZZLE_B
#define GL_TEXTURE_SWIZZLE_B                                            0x8E44
#endif //GL_TEXTURE_SWIZZLE_B
#ifndef GL_TEXTURE_SWIZZLE_A
#define GL_TEXTURE_SWIZZLE_A                                            0x8E45
#endif //GL_TEXTURE_SWIZZLE_A
#ifndef GL_TEXTURE_SWIZZLE_RGBA
#define GL_TEXTURE_SWIZZLE_RGBA                                         0x8E46
#endif //GL_TEXTURE_SWIZZLE_RGBA

#endif //GL_ARB_texture_swizzle

#ifndef GL_ARB_texture_view

#define GL_ARB_texture_view
#ifndef GL_TEXTURE_VIEW_MIN_LEVEL
#define GL_TEXTURE_VIEW_MIN_LEVEL                                       0x82DB
#endif //GL_TEXTURE_VIEW_MIN_LEVEL
#ifndef GL_TEXTURE_VIEW_NUM_LEVELS
#define GL_TEXTURE_VIEW_NUM_LEVELS                                      0x82DC
#endif //GL_TEXTURE_VIEW_NUM_LEVELS
#ifndef GL_TEXTURE_VIEW_MIN_LAYER
#define GL_TEXTURE_VIEW_MIN_LAYER                                       0x82DD
#endif //GL_TEXTURE_VIEW_MIN_LAYER
#ifndef GL_TEXTURE_VIEW_NUM_LAYERS
#define GL_TEXTURE_VIEW_NUM_LAYERS                                      0x82DE
#endif //GL_TEXTURE_VIEW_NUM_LAYERS
#ifndef GL_TEXTURE_IMMUTABLE_LEVELS
#define GL_TEXTURE_IMMUTABLE_LEVELS                                     0x82DF
#endif //GL_TEXTURE_IMMUTABLE_LEVELS

#endif //GL_ARB_texture_view


typedef void (*PFNTEXTUREVIEWPROC_HPP)(GLuint texture,GLenum target,GLuint origtexture,GLenum internalformat,GLuint minlevel,GLuint numlevels,GLuint minlayer,GLuint numlayers);

static inline void TextureView(GLuint texture,GLenum target,GLuint origtexture,GLenum internalformat,GLuint minlevel,GLuint numlevels,GLuint minlayer,GLuint numlayers)
{
	static PFNTEXTUREVIEWPROC_HPP fn=reinterpret_cast<PFNTEXTUREVIEWPROC_HPP>(_impl::_get_proc_address("glTextureView","GL_ARB_texture_view"));
	 fn(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers);
}
#ifndef GL_ARB_timer_query

#define GL_ARB_timer_query
#ifndef GL_TIME_ELAPSED
#define GL_TIME_ELAPSED                                                 0x88BF
#endif //GL_TIME_ELAPSED
#ifndef GL_TIMESTAMP
#define GL_TIMESTAMP                                                    0x8E28
#endif //GL_TIMESTAMP

#endif //GL_ARB_timer_query


typedef void (*PFNQUERYCOUNTERPROC_HPP)(GLuint id,GLenum target);

static inline void QueryCounter(GLuint id,GLenum target)
{
	static PFNQUERYCOUNTERPROC_HPP fn=reinterpret_cast<PFNQUERYCOUNTERPROC_HPP>(_impl::_get_proc_address("glQueryCounter","GL_ARB_timer_query"));
	 fn(id,target);
}

typedef void (*PFNGETQUERYOBJECTI64VPROC_HPP)(GLuint id,GLenum pname,GLint64 *params);

static inline void GetQueryObjecti64v(GLuint id,GLenum pname,GLint64 *params)
{
	static PFNGETQUERYOBJECTI64VPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTI64VPROC_HPP>(_impl::_get_proc_address("glGetQueryObjecti64v","GL_ARB_timer_query"));
	 fn(id,pname,params);
}

typedef void (*PFNGETQUERYOBJECTUI64VPROC_HPP)(GLuint id,GLenum pname,GLuint64 *params);

static inline void GetQueryObjectui64v(GLuint id,GLenum pname,GLuint64 *params)
{
	static PFNGETQUERYOBJECTUI64VPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTUI64VPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectui64v","GL_ARB_timer_query"));
	 fn(id,pname,params);
}
#ifndef GL_ARB_transform_feedback2

#define GL_ARB_transform_feedback2
#ifndef GL_TRANSFORM_FEEDBACK
#define GL_TRANSFORM_FEEDBACK                                           0x8E22
#endif //GL_TRANSFORM_FEEDBACK
#ifndef GL_TRANSFORM_FEEDBACK_PAUSED
#define GL_TRANSFORM_FEEDBACK_PAUSED                                    0x8E23
#endif //GL_TRANSFORM_FEEDBACK_PAUSED
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED
#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED                             0x8E23
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE
#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE                             0x8E24
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE
#ifndef GL_TRANSFORM_FEEDBACK_ACTIVE
#define GL_TRANSFORM_FEEDBACK_ACTIVE                                    0x8E24
#endif //GL_TRANSFORM_FEEDBACK_ACTIVE
#ifndef GL_TRANSFORM_FEEDBACK_BINDING
#define GL_TRANSFORM_FEEDBACK_BINDING                                   0x8E25
#endif //GL_TRANSFORM_FEEDBACK_BINDING

#endif //GL_ARB_transform_feedback2


typedef void (*PFNBINDTRANSFORMFEEDBACKPROC_HPP)(GLenum target,GLuint id);

static inline void BindTransformFeedback(GLenum target,GLuint id)
{
	static PFNBINDTRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNBINDTRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glBindTransformFeedback","GL_ARB_transform_feedback2"));
	 fn(target,id);
}

typedef void (*PFNDELETETRANSFORMFEEDBACKSPROC_HPP)(GLsizei n,const GLuint *ids);

static inline void DeleteTransformFeedbacks(GLsizei n,const GLuint *ids)
{
	static PFNDELETETRANSFORMFEEDBACKSPROC_HPP fn=reinterpret_cast<PFNDELETETRANSFORMFEEDBACKSPROC_HPP>(_impl::_get_proc_address("glDeleteTransformFeedbacks","GL_ARB_transform_feedback2"));
	 fn(n,ids);
}

typedef void (*PFNGENTRANSFORMFEEDBACKSPROC_HPP)(GLsizei n,GLuint *ids);

static inline void GenTransformFeedbacks(GLsizei n,GLuint *ids)
{
	static PFNGENTRANSFORMFEEDBACKSPROC_HPP fn=reinterpret_cast<PFNGENTRANSFORMFEEDBACKSPROC_HPP>(_impl::_get_proc_address("glGenTransformFeedbacks","GL_ARB_transform_feedback2"));
	 fn(n,ids);
}

typedef GLboolean (*PFNISTRANSFORMFEEDBACKPROC_HPP)(GLuint id);

static inline GLboolean IsTransformFeedback(GLuint id)
{
	static PFNISTRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNISTRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glIsTransformFeedback","GL_ARB_transform_feedback2"));
	return fn(id);
}

typedef void (*PFNPAUSETRANSFORMFEEDBACKPROC_HPP)();

static inline void PauseTransformFeedback()
{
	static PFNPAUSETRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNPAUSETRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glPauseTransformFeedback","GL_ARB_transform_feedback2"));
	 fn();
}

typedef void (*PFNRESUMETRANSFORMFEEDBACKPROC_HPP)();

static inline void ResumeTransformFeedback()
{
	static PFNRESUMETRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNRESUMETRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glResumeTransformFeedback","GL_ARB_transform_feedback2"));
	 fn();
}

typedef void (*PFNDRAWTRANSFORMFEEDBACKPROC_HPP)(GLenum mode,GLuint id);

static inline void DrawTransformFeedback(GLenum mode,GLuint id)
{
	static PFNDRAWTRANSFORMFEEDBACKPROC_HPP fn=reinterpret_cast<PFNDRAWTRANSFORMFEEDBACKPROC_HPP>(_impl::_get_proc_address("glDrawTransformFeedback","GL_ARB_transform_feedback2"));
	 fn(mode,id);
}
#ifndef GL_ARB_transform_feedback3

#define GL_ARB_transform_feedback3
#ifndef GL_MAX_TRANSFORM_FEEDBACK_BUFFERS
#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS                               0x8E70
#endif //GL_MAX_TRANSFORM_FEEDBACK_BUFFERS

#endif //GL_ARB_transform_feedback3


typedef void (*PFNDRAWTRANSFORMFEEDBACKSTREAMPROC_HPP)(GLenum mode,GLuint id,GLuint stream);

static inline void DrawTransformFeedbackStream(GLenum mode,GLuint id,GLuint stream)
{
	static PFNDRAWTRANSFORMFEEDBACKSTREAMPROC_HPP fn=reinterpret_cast<PFNDRAWTRANSFORMFEEDBACKSTREAMPROC_HPP>(_impl::_get_proc_address("glDrawTransformFeedbackStream","GL_ARB_transform_feedback3"));
	 fn(mode,id,stream);
}

typedef void (*PFNBEGINQUERYINDEXEDPROC_HPP)(GLenum target,GLuint index,GLuint id);

static inline void BeginQueryIndexed(GLenum target,GLuint index,GLuint id)
{
	static PFNBEGINQUERYINDEXEDPROC_HPP fn=reinterpret_cast<PFNBEGINQUERYINDEXEDPROC_HPP>(_impl::_get_proc_address("glBeginQueryIndexed","GL_ARB_transform_feedback3"));
	 fn(target,index,id);
}

typedef void (*PFNENDQUERYINDEXEDPROC_HPP)(GLenum target,GLuint index);

static inline void EndQueryIndexed(GLenum target,GLuint index)
{
	static PFNENDQUERYINDEXEDPROC_HPP fn=reinterpret_cast<PFNENDQUERYINDEXEDPROC_HPP>(_impl::_get_proc_address("glEndQueryIndexed","GL_ARB_transform_feedback3"));
	 fn(target,index);
}

typedef void (*PFNGETQUERYINDEXEDIVPROC_HPP)(GLenum target,GLuint index,GLenum pname,GLint *params);

static inline void GetQueryIndexediv(GLenum target,GLuint index,GLenum pname,GLint *params)
{
	static PFNGETQUERYINDEXEDIVPROC_HPP fn=reinterpret_cast<PFNGETQUERYINDEXEDIVPROC_HPP>(_impl::_get_proc_address("glGetQueryIndexediv","GL_ARB_transform_feedback3"));
	 fn(target,index,pname,params);
}
#ifndef GL_ARB_transform_feedback_instanced

#define GL_ARB_transform_feedback_instanced

#endif //GL_ARB_transform_feedback_instanced


typedef void (*PFNDRAWTRANSFORMFEEDBACKINSTANCEDPROC_HPP)(GLenum mode,GLuint id,GLsizei instancecount);

static inline void DrawTransformFeedbackInstanced(GLenum mode,GLuint id,GLsizei instancecount)
{
	static PFNDRAWTRANSFORMFEEDBACKINSTANCEDPROC_HPP fn=reinterpret_cast<PFNDRAWTRANSFORMFEEDBACKINSTANCEDPROC_HPP>(_impl::_get_proc_address("glDrawTransformFeedbackInstanced","GL_ARB_transform_feedback_instanced"));
	 fn(mode,id,instancecount);
}

typedef void (*PFNDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC_HPP)(GLenum mode,GLuint id,GLuint stream,GLsizei instancecount);

static inline void DrawTransformFeedbackStreamInstanced(GLenum mode,GLuint id,GLuint stream,GLsizei instancecount)
{
	static PFNDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC_HPP fn=reinterpret_cast<PFNDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC_HPP>(_impl::_get_proc_address("glDrawTransformFeedbackStreamInstanced","GL_ARB_transform_feedback_instanced"));
	 fn(mode,id,stream,instancecount);
}
#ifndef GL_ARB_transpose_matrix

#define GL_ARB_transpose_matrix
#ifndef GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB                               0x84E3
#endif //GL_TRANSPOSE_MODELVIEW_MATRIX_ARB
#ifndef GL_TRANSPOSE_PROJECTION_MATRIX_ARB
#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB                              0x84E4
#endif //GL_TRANSPOSE_PROJECTION_MATRIX_ARB
#ifndef GL_TRANSPOSE_TEXTURE_MATRIX_ARB
#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB                                 0x84E5
#endif //GL_TRANSPOSE_TEXTURE_MATRIX_ARB
#ifndef GL_TRANSPOSE_COLOR_MATRIX_ARB
#define GL_TRANSPOSE_COLOR_MATRIX_ARB                                   0x84E6
#endif //GL_TRANSPOSE_COLOR_MATRIX_ARB

#endif //GL_ARB_transpose_matrix


typedef void (*PFNLOADTRANSPOSEMATRIXFARBPROC_HPP)(const GLfloat *m);

static inline void LoadTransposeMatrixfARB(const GLfloat *m)
{
	static PFNLOADTRANSPOSEMATRIXFARBPROC_HPP fn=reinterpret_cast<PFNLOADTRANSPOSEMATRIXFARBPROC_HPP>(_impl::_get_proc_address("glLoadTransposeMatrixfARB","GL_ARB_transpose_matrix"));
	 fn(m);
}

typedef void (*PFNLOADTRANSPOSEMATRIXDARBPROC_HPP)(const GLdouble *m);

static inline void LoadTransposeMatrixdARB(const GLdouble *m)
{
	static PFNLOADTRANSPOSEMATRIXDARBPROC_HPP fn=reinterpret_cast<PFNLOADTRANSPOSEMATRIXDARBPROC_HPP>(_impl::_get_proc_address("glLoadTransposeMatrixdARB","GL_ARB_transpose_matrix"));
	 fn(m);
}

typedef void (*PFNMULTTRANSPOSEMATRIXFARBPROC_HPP)(const GLfloat *m);

static inline void MultTransposeMatrixfARB(const GLfloat *m)
{
	static PFNMULTTRANSPOSEMATRIXFARBPROC_HPP fn=reinterpret_cast<PFNMULTTRANSPOSEMATRIXFARBPROC_HPP>(_impl::_get_proc_address("glMultTransposeMatrixfARB","GL_ARB_transpose_matrix"));
	 fn(m);
}

typedef void (*PFNMULTTRANSPOSEMATRIXDARBPROC_HPP)(const GLdouble *m);

static inline void MultTransposeMatrixdARB(const GLdouble *m)
{
	static PFNMULTTRANSPOSEMATRIXDARBPROC_HPP fn=reinterpret_cast<PFNMULTTRANSPOSEMATRIXDARBPROC_HPP>(_impl::_get_proc_address("glMultTransposeMatrixdARB","GL_ARB_transpose_matrix"));
	 fn(m);
}
#ifndef GL_ARB_uniform_buffer_object

#define GL_ARB_uniform_buffer_object

#endif //GL_ARB_uniform_buffer_object


typedef void (*PFNGETUNIFORMINDICESPROC_HPP)(GLuint program,GLsizei uniformCount,const GLchar* const *uniformNames,GLuint *uniformIndices);

static inline void GetUniformIndices(GLuint program,GLsizei uniformCount,const GLchar* const *uniformNames,GLuint *uniformIndices)
{
	static PFNGETUNIFORMINDICESPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMINDICESPROC_HPP>(_impl::_get_proc_address("glGetUniformIndices","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformCount,uniformNames,uniformIndices);
}

typedef void (*PFNGETACTIVEUNIFORMSIVPROC_HPP)(GLuint program,GLsizei uniformCount,const GLuint *uniformIndices,GLenum pname,GLint *params);

static inline void GetActiveUniformsiv(GLuint program,GLsizei uniformCount,const GLuint *uniformIndices,GLenum pname,GLint *params)
{
	static PFNGETACTIVEUNIFORMSIVPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMSIVPROC_HPP>(_impl::_get_proc_address("glGetActiveUniformsiv","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformCount,uniformIndices,pname,params);
}

typedef void (*PFNGETACTIVEUNIFORMNAMEPROC_HPP)(GLuint program,GLuint uniformIndex,GLsizei bufSize,GLsizei *length,GLchar *uniformName);

static inline void GetActiveUniformName(GLuint program,GLuint uniformIndex,GLsizei bufSize,GLsizei *length,GLchar *uniformName)
{
	static PFNGETACTIVEUNIFORMNAMEPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMNAMEPROC_HPP>(_impl::_get_proc_address("glGetActiveUniformName","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformIndex,bufSize,length,uniformName);
}

typedef GLuint (*PFNGETUNIFORMBLOCKINDEXPROC_HPP)(GLuint program,const GLchar *uniformBlockName);

static inline GLuint GetUniformBlockIndex(GLuint program,const GLchar *uniformBlockName)
{
	static PFNGETUNIFORMBLOCKINDEXPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMBLOCKINDEXPROC_HPP>(_impl::_get_proc_address("glGetUniformBlockIndex","GL_ARB_uniform_buffer_object"));
	return fn(program,uniformBlockName);
}

typedef void (*PFNGETACTIVEUNIFORMBLOCKIVPROC_HPP)(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint *params);

static inline void GetActiveUniformBlockiv(GLuint program,GLuint uniformBlockIndex,GLenum pname,GLint *params)
{
	static PFNGETACTIVEUNIFORMBLOCKIVPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMBLOCKIVPROC_HPP>(_impl::_get_proc_address("glGetActiveUniformBlockiv","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformBlockIndex,pname,params);
}

typedef void (*PFNGETACTIVEUNIFORMBLOCKNAMEPROC_HPP)(GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei *length,GLchar *uniformBlockName);

static inline void GetActiveUniformBlockName(GLuint program,GLuint uniformBlockIndex,GLsizei bufSize,GLsizei *length,GLchar *uniformBlockName)
{
	static PFNGETACTIVEUNIFORMBLOCKNAMEPROC_HPP fn=reinterpret_cast<PFNGETACTIVEUNIFORMBLOCKNAMEPROC_HPP>(_impl::_get_proc_address("glGetActiveUniformBlockName","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformBlockIndex,bufSize,length,uniformBlockName);
}

typedef void (*PFNUNIFORMBLOCKBINDINGPROC_HPP)(GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding);

static inline void UniformBlockBinding(GLuint program,GLuint uniformBlockIndex,GLuint uniformBlockBinding)
{
	static PFNUNIFORMBLOCKBINDINGPROC_HPP fn=reinterpret_cast<PFNUNIFORMBLOCKBINDINGPROC_HPP>(_impl::_get_proc_address("glUniformBlockBinding","GL_ARB_uniform_buffer_object"));
	 fn(program,uniformBlockIndex,uniformBlockBinding);
}
#ifndef GL_ARB_vertex_array_object

#define GL_ARB_vertex_array_object

#endif //GL_ARB_vertex_array_object


typedef void (*PFNBINDVERTEXARRAYPROC_HPP)(GLuint array);

static inline void BindVertexArray(GLuint array)
{
	static PFNBINDVERTEXARRAYPROC_HPP fn=reinterpret_cast<PFNBINDVERTEXARRAYPROC_HPP>(_impl::_get_proc_address("glBindVertexArray","GL_ARB_vertex_array_object"));
	 fn(array);
}

typedef void (*PFNDELETEVERTEXARRAYSPROC_HPP)(GLsizei n,const GLuint *arrays);

static inline void DeleteVertexArrays(GLsizei n,const GLuint *arrays)
{
	static PFNDELETEVERTEXARRAYSPROC_HPP fn=reinterpret_cast<PFNDELETEVERTEXARRAYSPROC_HPP>(_impl::_get_proc_address("glDeleteVertexArrays","GL_ARB_vertex_array_object"));
	 fn(n,arrays);
}

typedef void (*PFNGENVERTEXARRAYSPROC_HPP)(GLsizei n,GLuint *arrays);

static inline void GenVertexArrays(GLsizei n,GLuint *arrays)
{
	static PFNGENVERTEXARRAYSPROC_HPP fn=reinterpret_cast<PFNGENVERTEXARRAYSPROC_HPP>(_impl::_get_proc_address("glGenVertexArrays","GL_ARB_vertex_array_object"));
	 fn(n,arrays);
}

typedef GLboolean (*PFNISVERTEXARRAYPROC_HPP)(GLuint array);

static inline GLboolean IsVertexArray(GLuint array)
{
	static PFNISVERTEXARRAYPROC_HPP fn=reinterpret_cast<PFNISVERTEXARRAYPROC_HPP>(_impl::_get_proc_address("glIsVertexArray","GL_ARB_vertex_array_object"));
	return fn(array);
}
#ifndef GL_ARB_vertex_attrib_64bit

#define GL_ARB_vertex_attrib_64bit

#endif //GL_ARB_vertex_attrib_64bit


typedef void (*PFNVERTEXATTRIBL1DPROC_HPP)(GLuint index,GLdouble x);

static inline void VertexAttribL1d(GLuint index,GLdouble x)
{
	static PFNVERTEXATTRIBL1DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1DPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1d","GL_ARB_vertex_attrib_64bit"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBL2DPROC_HPP)(GLuint index,GLdouble x,GLdouble y);

static inline void VertexAttribL2d(GLuint index,GLdouble x,GLdouble y)
{
	static PFNVERTEXATTRIBL2DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2DPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2d","GL_ARB_vertex_attrib_64bit"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBL3DPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexAttribL3d(GLuint index,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXATTRIBL3DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3DPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3d","GL_ARB_vertex_attrib_64bit"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBL4DPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexAttribL4d(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXATTRIBL4DPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4DPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4d","GL_ARB_vertex_attrib_64bit"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBL1DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL1dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL1DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1DVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1dv","GL_ARB_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL2DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL2dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL2DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2DVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2dv","GL_ARB_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL3DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL3dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL3DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3DVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3dv","GL_ARB_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL4DVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL4dv(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL4DVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4DVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4dv","GL_ARB_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBLPOINTERPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribLPointer(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBLPOINTERPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBLPOINTERPROC_HPP>(_impl::_get_proc_address("glVertexAttribLPointer","GL_ARB_vertex_attrib_64bit"));
	 fn(index,size,type,stride,pointer);
}

typedef void (*PFNGETVERTEXATTRIBLDVPROC_HPP)(GLuint index,GLenum pname,GLdouble *params);

static inline void GetVertexAttribLdv(GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETVERTEXATTRIBLDVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBLDVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribLdv","GL_ARB_vertex_attrib_64bit"));
	 fn(index,pname,params);
}
#ifndef GL_ARB_vertex_attrib_binding

#define GL_ARB_vertex_attrib_binding
#ifndef GL_VERTEX_ATTRIB_BINDING
#define GL_VERTEX_ATTRIB_BINDING                                        0x82D4
#endif //GL_VERTEX_ATTRIB_BINDING
#ifndef GL_VERTEX_ATTRIB_RELATIVE_OFFSET
#define GL_VERTEX_ATTRIB_RELATIVE_OFFSET                                0x82D5
#endif //GL_VERTEX_ATTRIB_RELATIVE_OFFSET
#ifndef GL_VERTEX_BINDING_DIVISOR
#define GL_VERTEX_BINDING_DIVISOR                                       0x82D6
#endif //GL_VERTEX_BINDING_DIVISOR
#ifndef GL_VERTEX_BINDING_OFFSET
#define GL_VERTEX_BINDING_OFFSET                                        0x82D7
#endif //GL_VERTEX_BINDING_OFFSET
#ifndef GL_VERTEX_BINDING_STRIDE
#define GL_VERTEX_BINDING_STRIDE                                        0x82D8
#endif //GL_VERTEX_BINDING_STRIDE
#ifndef GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET
#define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET                            0x82D9
#endif //GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET
#ifndef GL_MAX_VERTEX_ATTRIB_BINDINGS
#define GL_MAX_VERTEX_ATTRIB_BINDINGS                                   0x82DA
#endif //GL_MAX_VERTEX_ATTRIB_BINDINGS

#endif //GL_ARB_vertex_attrib_binding


typedef void (*PFNBINDVERTEXBUFFERPROC_HPP)(GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride);

static inline void BindVertexBuffer(GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride)
{
	static PFNBINDVERTEXBUFFERPROC_HPP fn=reinterpret_cast<PFNBINDVERTEXBUFFERPROC_HPP>(_impl::_get_proc_address("glBindVertexBuffer","GL_ARB_vertex_attrib_binding"));
	 fn(bindingindex,buffer,offset,stride);
}

typedef void (*PFNVERTEXATTRIBFORMATPROC_HPP)(GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset);

static inline void VertexAttribFormat(GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset)
{
	static PFNVERTEXATTRIBFORMATPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBFORMATPROC_HPP>(_impl::_get_proc_address("glVertexAttribFormat","GL_ARB_vertex_attrib_binding"));
	 fn(attribindex,size,type,normalized,relativeoffset);
}

typedef void (*PFNVERTEXATTRIBIFORMATPROC_HPP)(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);

static inline void VertexAttribIFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)
{
	static PFNVERTEXATTRIBIFORMATPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBIFORMATPROC_HPP>(_impl::_get_proc_address("glVertexAttribIFormat","GL_ARB_vertex_attrib_binding"));
	 fn(attribindex,size,type,relativeoffset);
}

typedef void (*PFNVERTEXATTRIBLFORMATPROC_HPP)(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);

static inline void VertexAttribLFormat(GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)
{
	static PFNVERTEXATTRIBLFORMATPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBLFORMATPROC_HPP>(_impl::_get_proc_address("glVertexAttribLFormat","GL_ARB_vertex_attrib_binding"));
	 fn(attribindex,size,type,relativeoffset);
}

typedef void (*PFNVERTEXATTRIBBINDINGPROC_HPP)(GLuint attribindex,GLuint bindingindex);

static inline void VertexAttribBinding(GLuint attribindex,GLuint bindingindex)
{
	static PFNVERTEXATTRIBBINDINGPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBBINDINGPROC_HPP>(_impl::_get_proc_address("glVertexAttribBinding","GL_ARB_vertex_attrib_binding"));
	 fn(attribindex,bindingindex);
}

typedef void (*PFNVERTEXBINDINGDIVISORPROC_HPP)(GLuint bindingindex,GLuint divisor);

static inline void VertexBindingDivisor(GLuint bindingindex,GLuint divisor)
{
	static PFNVERTEXBINDINGDIVISORPROC_HPP fn=reinterpret_cast<PFNVERTEXBINDINGDIVISORPROC_HPP>(_impl::_get_proc_address("glVertexBindingDivisor","GL_ARB_vertex_attrib_binding"));
	 fn(bindingindex,divisor);
}

typedef void (*PFNVERTEXARRAYBINDVERTEXBUFFEREXTPROC_HPP)(GLuint vaobj,GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride);

static inline void VertexArrayBindVertexBufferEXT(GLuint vaobj,GLuint bindingindex,GLuint buffer,GLintptr offset,GLsizei stride)
{
	static PFNVERTEXARRAYBINDVERTEXBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYBINDVERTEXBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayBindVertexBufferEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,bindingindex,buffer,offset,stride);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBFORMATEXTPROC_HPP)(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset);

static inline void VertexArrayVertexAttribFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLboolean normalized,GLuint relativeoffset)
{
	static PFNVERTEXARRAYVERTEXATTRIBFORMATEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBFORMATEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribFormatEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,attribindex,size,type,normalized,relativeoffset);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC_HPP)(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);

static inline void VertexArrayVertexAttribIFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)
{
	static PFNVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBIFORMATEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribIFormatEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,attribindex,size,type,relativeoffset);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC_HPP)(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset);

static inline void VertexArrayVertexAttribLFormatEXT(GLuint vaobj,GLuint attribindex,GLint size,GLenum type,GLuint relativeoffset)
{
	static PFNVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBLFORMATEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribLFormatEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,attribindex,size,type,relativeoffset);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC_HPP)(GLuint vaobj,GLuint attribindex,GLuint bindingindex);

static inline void VertexArrayVertexAttribBindingEXT(GLuint vaobj,GLuint attribindex,GLuint bindingindex)
{
	static PFNVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBBINDINGEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribBindingEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,attribindex,bindingindex);
}

typedef void (*PFNVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC_HPP)(GLuint vaobj,GLuint bindingindex,GLuint divisor);

static inline void VertexArrayVertexBindingDivisorEXT(GLuint vaobj,GLuint bindingindex,GLuint divisor)
{
	static PFNVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXBINDINGDIVISOREXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexBindingDivisorEXT","GL_ARB_vertex_attrib_binding"));
	 fn(vaobj,bindingindex,divisor);
}
#ifndef GL_ARB_vertex_blend

#define GL_ARB_vertex_blend
#ifndef GL_MODELVIEW0_ARB
#define GL_MODELVIEW0_ARB                                               0x1700
#endif //GL_MODELVIEW0_ARB
#ifndef GL_MODELVIEW1_ARB
#define GL_MODELVIEW1_ARB                                               0x850A
#endif //GL_MODELVIEW1_ARB
#ifndef GL_MAX_VERTEX_UNITS_ARB
#define GL_MAX_VERTEX_UNITS_ARB                                         0x86A4
#endif //GL_MAX_VERTEX_UNITS_ARB
#ifndef GL_ACTIVE_VERTEX_UNITS_ARB
#define GL_ACTIVE_VERTEX_UNITS_ARB                                      0x86A5
#endif //GL_ACTIVE_VERTEX_UNITS_ARB
#ifndef GL_WEIGHT_SUM_UNITY_ARB
#define GL_WEIGHT_SUM_UNITY_ARB                                         0x86A6
#endif //GL_WEIGHT_SUM_UNITY_ARB
#ifndef GL_VERTEX_BLEND_ARB
#define GL_VERTEX_BLEND_ARB                                             0x86A7
#endif //GL_VERTEX_BLEND_ARB
#ifndef GL_CURRENT_WEIGHT_ARB
#define GL_CURRENT_WEIGHT_ARB                                           0x86A8
#endif //GL_CURRENT_WEIGHT_ARB
#ifndef GL_WEIGHT_ARRAY_TYPE_ARB
#define GL_WEIGHT_ARRAY_TYPE_ARB                                        0x86A9
#endif //GL_WEIGHT_ARRAY_TYPE_ARB
#ifndef GL_WEIGHT_ARRAY_STRIDE_ARB
#define GL_WEIGHT_ARRAY_STRIDE_ARB                                      0x86AA
#endif //GL_WEIGHT_ARRAY_STRIDE_ARB
#ifndef GL_WEIGHT_ARRAY_SIZE_ARB
#define GL_WEIGHT_ARRAY_SIZE_ARB                                        0x86AB
#endif //GL_WEIGHT_ARRAY_SIZE_ARB
#ifndef GL_WEIGHT_ARRAY_POINTER_ARB
#define GL_WEIGHT_ARRAY_POINTER_ARB                                     0x86AC
#endif //GL_WEIGHT_ARRAY_POINTER_ARB
#ifndef GL_WEIGHT_ARRAY_ARB
#define GL_WEIGHT_ARRAY_ARB                                             0x86AD
#endif //GL_WEIGHT_ARRAY_ARB
#ifndef GL_MODELVIEW2_ARB
#define GL_MODELVIEW2_ARB                                               0x8722
#endif //GL_MODELVIEW2_ARB
#ifndef GL_MODELVIEW3_ARB
#define GL_MODELVIEW3_ARB                                               0x8723
#endif //GL_MODELVIEW3_ARB
#ifndef GL_MODELVIEW4_ARB
#define GL_MODELVIEW4_ARB                                               0x8724
#endif //GL_MODELVIEW4_ARB
#ifndef GL_MODELVIEW5_ARB
#define GL_MODELVIEW5_ARB                                               0x8725
#endif //GL_MODELVIEW5_ARB
#ifndef GL_MODELVIEW6_ARB
#define GL_MODELVIEW6_ARB                                               0x8726
#endif //GL_MODELVIEW6_ARB
#ifndef GL_MODELVIEW7_ARB
#define GL_MODELVIEW7_ARB                                               0x8727
#endif //GL_MODELVIEW7_ARB
#ifndef GL_MODELVIEW8_ARB
#define GL_MODELVIEW8_ARB                                               0x8728
#endif //GL_MODELVIEW8_ARB
#ifndef GL_MODELVIEW9_ARB
#define GL_MODELVIEW9_ARB                                               0x8729
#endif //GL_MODELVIEW9_ARB
#ifndef GL_MODELVIEW10_ARB
#define GL_MODELVIEW10_ARB                                              0x872A
#endif //GL_MODELVIEW10_ARB
#ifndef GL_MODELVIEW11_ARB
#define GL_MODELVIEW11_ARB                                              0x872B
#endif //GL_MODELVIEW11_ARB
#ifndef GL_MODELVIEW12_ARB
#define GL_MODELVIEW12_ARB                                              0x872C
#endif //GL_MODELVIEW12_ARB
#ifndef GL_MODELVIEW13_ARB
#define GL_MODELVIEW13_ARB                                              0x872D
#endif //GL_MODELVIEW13_ARB
#ifndef GL_MODELVIEW14_ARB
#define GL_MODELVIEW14_ARB                                              0x872E
#endif //GL_MODELVIEW14_ARB
#ifndef GL_MODELVIEW15_ARB
#define GL_MODELVIEW15_ARB                                              0x872F
#endif //GL_MODELVIEW15_ARB
#ifndef GL_MODELVIEW16_ARB
#define GL_MODELVIEW16_ARB                                              0x8730
#endif //GL_MODELVIEW16_ARB
#ifndef GL_MODELVIEW17_ARB
#define GL_MODELVIEW17_ARB                                              0x8731
#endif //GL_MODELVIEW17_ARB
#ifndef GL_MODELVIEW18_ARB
#define GL_MODELVIEW18_ARB                                              0x8732
#endif //GL_MODELVIEW18_ARB
#ifndef GL_MODELVIEW19_ARB
#define GL_MODELVIEW19_ARB                                              0x8733
#endif //GL_MODELVIEW19_ARB
#ifndef GL_MODELVIEW20_ARB
#define GL_MODELVIEW20_ARB                                              0x8734
#endif //GL_MODELVIEW20_ARB
#ifndef GL_MODELVIEW21_ARB
#define GL_MODELVIEW21_ARB                                              0x8735
#endif //GL_MODELVIEW21_ARB
#ifndef GL_MODELVIEW22_ARB
#define GL_MODELVIEW22_ARB                                              0x8736
#endif //GL_MODELVIEW22_ARB
#ifndef GL_MODELVIEW23_ARB
#define GL_MODELVIEW23_ARB                                              0x8737
#endif //GL_MODELVIEW23_ARB
#ifndef GL_MODELVIEW24_ARB
#define GL_MODELVIEW24_ARB                                              0x8738
#endif //GL_MODELVIEW24_ARB
#ifndef GL_MODELVIEW25_ARB
#define GL_MODELVIEW25_ARB                                              0x8739
#endif //GL_MODELVIEW25_ARB
#ifndef GL_MODELVIEW26_ARB
#define GL_MODELVIEW26_ARB                                              0x873A
#endif //GL_MODELVIEW26_ARB
#ifndef GL_MODELVIEW27_ARB
#define GL_MODELVIEW27_ARB                                              0x873B
#endif //GL_MODELVIEW27_ARB
#ifndef GL_MODELVIEW28_ARB
#define GL_MODELVIEW28_ARB                                              0x873C
#endif //GL_MODELVIEW28_ARB
#ifndef GL_MODELVIEW29_ARB
#define GL_MODELVIEW29_ARB                                              0x873D
#endif //GL_MODELVIEW29_ARB
#ifndef GL_MODELVIEW30_ARB
#define GL_MODELVIEW30_ARB                                              0x873E
#endif //GL_MODELVIEW30_ARB
#ifndef GL_MODELVIEW31_ARB
#define GL_MODELVIEW31_ARB                                              0x873F
#endif //GL_MODELVIEW31_ARB

#endif //GL_ARB_vertex_blend


typedef void (*PFNWEIGHTBVARBPROC_HPP)(GLint size,const GLbyte *weights);

static inline void WeightbvARB(GLint size,const GLbyte *weights)
{
	static PFNWEIGHTBVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTBVARBPROC_HPP>(_impl::_get_proc_address("glWeightbvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTSVARBPROC_HPP)(GLint size,const GLshort *weights);

static inline void WeightsvARB(GLint size,const GLshort *weights)
{
	static PFNWEIGHTSVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTSVARBPROC_HPP>(_impl::_get_proc_address("glWeightsvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTIVARBPROC_HPP)(GLint size,const GLint *weights);

static inline void WeightivARB(GLint size,const GLint *weights)
{
	static PFNWEIGHTIVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTIVARBPROC_HPP>(_impl::_get_proc_address("glWeightivARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTFVARBPROC_HPP)(GLint size,const GLfloat *weights);

static inline void WeightfvARB(GLint size,const GLfloat *weights)
{
	static PFNWEIGHTFVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTFVARBPROC_HPP>(_impl::_get_proc_address("glWeightfvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTDVARBPROC_HPP)(GLint size,const GLdouble *weights);

static inline void WeightdvARB(GLint size,const GLdouble *weights)
{
	static PFNWEIGHTDVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTDVARBPROC_HPP>(_impl::_get_proc_address("glWeightdvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTUBVARBPROC_HPP)(GLint size,const GLubyte *weights);

static inline void WeightubvARB(GLint size,const GLubyte *weights)
{
	static PFNWEIGHTUBVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTUBVARBPROC_HPP>(_impl::_get_proc_address("glWeightubvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTUSVARBPROC_HPP)(GLint size,const GLushort *weights);

static inline void WeightusvARB(GLint size,const GLushort *weights)
{
	static PFNWEIGHTUSVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTUSVARBPROC_HPP>(_impl::_get_proc_address("glWeightusvARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTUIVARBPROC_HPP)(GLint size,const GLuint *weights);

static inline void WeightuivARB(GLint size,const GLuint *weights)
{
	static PFNWEIGHTUIVARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTUIVARBPROC_HPP>(_impl::_get_proc_address("glWeightuivARB","GL_ARB_vertex_blend"));
	 fn(size,weights);
}

typedef void (*PFNWEIGHTPOINTERARBPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void WeightPointerARB(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNWEIGHTPOINTERARBPROC_HPP fn=reinterpret_cast<PFNWEIGHTPOINTERARBPROC_HPP>(_impl::_get_proc_address("glWeightPointerARB","GL_ARB_vertex_blend"));
	 fn(size,type,stride,pointer);
}

typedef void (*PFNVERTEXBLENDARBPROC_HPP)(GLint count);

static inline void VertexBlendARB(GLint count)
{
	static PFNVERTEXBLENDARBPROC_HPP fn=reinterpret_cast<PFNVERTEXBLENDARBPROC_HPP>(_impl::_get_proc_address("glVertexBlendARB","GL_ARB_vertex_blend"));
	 fn(count);
}
#ifndef GL_ARB_vertex_buffer_object

#define GL_ARB_vertex_buffer_object
#ifndef GL_BUFFER_SIZE_ARB
#define GL_BUFFER_SIZE_ARB                                              0x8764
#endif //GL_BUFFER_SIZE_ARB
#ifndef GL_BUFFER_USAGE_ARB
#define GL_BUFFER_USAGE_ARB                                             0x8765
#endif //GL_BUFFER_USAGE_ARB
#ifndef GL_ARRAY_BUFFER_ARB
#define GL_ARRAY_BUFFER_ARB                                             0x8892
#endif //GL_ARRAY_BUFFER_ARB
#ifndef GL_ELEMENT_ARRAY_BUFFER_ARB
#define GL_ELEMENT_ARRAY_BUFFER_ARB                                     0x8893
#endif //GL_ELEMENT_ARRAY_BUFFER_ARB
#ifndef GL_ARRAY_BUFFER_BINDING_ARB
#define GL_ARRAY_BUFFER_BINDING_ARB                                     0x8894
#endif //GL_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB
#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB                             0x8895
#endif //GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_VERTEX_ARRAY_BUFFER_BINDING_ARB
#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB                              0x8896
#endif //GL_VERTEX_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_NORMAL_ARRAY_BUFFER_BINDING_ARB
#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB                              0x8897
#endif //GL_NORMAL_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_COLOR_ARRAY_BUFFER_BINDING_ARB
#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB                               0x8898
#endif //GL_COLOR_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_INDEX_ARRAY_BUFFER_BINDING_ARB
#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB                               0x8899
#endif //GL_INDEX_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB
#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB                       0x889A
#endif //GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB
#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB                           0x889B
#endif //GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB
#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB                     0x889C
#endif //GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB
#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB                      0x889D
#endif //GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB
#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB                              0x889E
#endif //GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB                       0x889F
#endif //GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
#ifndef GL_READ_ONLY_ARB
#define GL_READ_ONLY_ARB                                                0x88B8
#endif //GL_READ_ONLY_ARB
#ifndef GL_WRITE_ONLY_ARB
#define GL_WRITE_ONLY_ARB                                               0x88B9
#endif //GL_WRITE_ONLY_ARB
#ifndef GL_READ_WRITE_ARB
#define GL_READ_WRITE_ARB                                               0x88BA
#endif //GL_READ_WRITE_ARB
#ifndef GL_BUFFER_ACCESS_ARB
#define GL_BUFFER_ACCESS_ARB                                            0x88BB
#endif //GL_BUFFER_ACCESS_ARB
#ifndef GL_BUFFER_MAPPED_ARB
#define GL_BUFFER_MAPPED_ARB                                            0x88BC
#endif //GL_BUFFER_MAPPED_ARB
#ifndef GL_BUFFER_MAP_POINTER_ARB
#define GL_BUFFER_MAP_POINTER_ARB                                       0x88BD
#endif //GL_BUFFER_MAP_POINTER_ARB
#ifndef GL_STREAM_DRAW_ARB
#define GL_STREAM_DRAW_ARB                                              0x88E0
#endif //GL_STREAM_DRAW_ARB
#ifndef GL_STREAM_READ_ARB
#define GL_STREAM_READ_ARB                                              0x88E1
#endif //GL_STREAM_READ_ARB
#ifndef GL_STREAM_COPY_ARB
#define GL_STREAM_COPY_ARB                                              0x88E2
#endif //GL_STREAM_COPY_ARB
#ifndef GL_STATIC_DRAW_ARB
#define GL_STATIC_DRAW_ARB                                              0x88E4
#endif //GL_STATIC_DRAW_ARB
#ifndef GL_STATIC_READ_ARB
#define GL_STATIC_READ_ARB                                              0x88E5
#endif //GL_STATIC_READ_ARB
#ifndef GL_STATIC_COPY_ARB
#define GL_STATIC_COPY_ARB                                              0x88E6
#endif //GL_STATIC_COPY_ARB
#ifndef GL_DYNAMIC_DRAW_ARB
#define GL_DYNAMIC_DRAW_ARB                                             0x88E8
#endif //GL_DYNAMIC_DRAW_ARB
#ifndef GL_DYNAMIC_READ_ARB
#define GL_DYNAMIC_READ_ARB                                             0x88E9
#endif //GL_DYNAMIC_READ_ARB
#ifndef GL_DYNAMIC_COPY_ARB
#define GL_DYNAMIC_COPY_ARB                                             0x88EA
#endif //GL_DYNAMIC_COPY_ARB

#endif //GL_ARB_vertex_buffer_object


typedef void (*PFNBINDBUFFERARBPROC_HPP)(GLenum target,GLuint buffer);

static inline void BindBufferARB(GLenum target,GLuint buffer)
{
	static PFNBINDBUFFERARBPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERARBPROC_HPP>(_impl::_get_proc_address("glBindBufferARB","GL_ARB_vertex_buffer_object"));
	 fn(target,buffer);
}

typedef void (*PFNDELETEBUFFERSARBPROC_HPP)(GLsizei n,const GLuint *buffers);

static inline void DeleteBuffersARB(GLsizei n,const GLuint *buffers)
{
	static PFNDELETEBUFFERSARBPROC_HPP fn=reinterpret_cast<PFNDELETEBUFFERSARBPROC_HPP>(_impl::_get_proc_address("glDeleteBuffersARB","GL_ARB_vertex_buffer_object"));
	 fn(n,buffers);
}

typedef void (*PFNGENBUFFERSARBPROC_HPP)(GLsizei n,GLuint *buffers);

static inline void GenBuffersARB(GLsizei n,GLuint *buffers)
{
	static PFNGENBUFFERSARBPROC_HPP fn=reinterpret_cast<PFNGENBUFFERSARBPROC_HPP>(_impl::_get_proc_address("glGenBuffersARB","GL_ARB_vertex_buffer_object"));
	 fn(n,buffers);
}

typedef GLboolean (*PFNISBUFFERARBPROC_HPP)(GLuint buffer);

static inline GLboolean IsBufferARB(GLuint buffer)
{
	static PFNISBUFFERARBPROC_HPP fn=reinterpret_cast<PFNISBUFFERARBPROC_HPP>(_impl::_get_proc_address("glIsBufferARB","GL_ARB_vertex_buffer_object"));
	return fn(buffer);
}

typedef void (*PFNBUFFERDATAARBPROC_HPP)(GLenum target,GLsizeiptrARB size,const GLvoid *data,GLenum usage);

static inline void BufferDataARB(GLenum target,GLsizeiptrARB size,const GLvoid *data,GLenum usage)
{
	static PFNBUFFERDATAARBPROC_HPP fn=reinterpret_cast<PFNBUFFERDATAARBPROC_HPP>(_impl::_get_proc_address("glBufferDataARB","GL_ARB_vertex_buffer_object"));
	 fn(target,size,data,usage);
}

typedef void (*PFNBUFFERSUBDATAARBPROC_HPP)(GLenum target,GLintptrARB offset,GLsizeiptrARB size,const GLvoid *data);

static inline void BufferSubDataARB(GLenum target,GLintptrARB offset,GLsizeiptrARB size,const GLvoid *data)
{
	static PFNBUFFERSUBDATAARBPROC_HPP fn=reinterpret_cast<PFNBUFFERSUBDATAARBPROC_HPP>(_impl::_get_proc_address("glBufferSubDataARB","GL_ARB_vertex_buffer_object"));
	 fn(target,offset,size,data);
}

typedef void (*PFNGETBUFFERSUBDATAARBPROC_HPP)(GLenum target,GLintptrARB offset,GLsizeiptrARB size,GLvoid *data);

static inline void GetBufferSubDataARB(GLenum target,GLintptrARB offset,GLsizeiptrARB size,GLvoid *data)
{
	static PFNGETBUFFERSUBDATAARBPROC_HPP fn=reinterpret_cast<PFNGETBUFFERSUBDATAARBPROC_HPP>(_impl::_get_proc_address("glGetBufferSubDataARB","GL_ARB_vertex_buffer_object"));
	 fn(target,offset,size,data);
}

typedef GLvoid* (*PFNMAPBUFFERARBPROC_HPP)(GLenum target,GLenum access);

static inline GLvoid* MapBufferARB(GLenum target,GLenum access)
{
	static PFNMAPBUFFERARBPROC_HPP fn=reinterpret_cast<PFNMAPBUFFERARBPROC_HPP>(_impl::_get_proc_address("glMapBufferARB","GL_ARB_vertex_buffer_object"));
	return fn(target,access);
}

typedef GLboolean (*PFNUNMAPBUFFERARBPROC_HPP)(GLenum target);

static inline GLboolean UnmapBufferARB(GLenum target)
{
	static PFNUNMAPBUFFERARBPROC_HPP fn=reinterpret_cast<PFNUNMAPBUFFERARBPROC_HPP>(_impl::_get_proc_address("glUnmapBufferARB","GL_ARB_vertex_buffer_object"));
	return fn(target);
}

typedef void (*PFNGETBUFFERPARAMETERIVARBPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetBufferParameterivARB(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETBUFFERPARAMETERIVARBPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPARAMETERIVARBPROC_HPP>(_impl::_get_proc_address("glGetBufferParameterivARB","GL_ARB_vertex_buffer_object"));
	 fn(target,pname,params);
}

typedef void (*PFNGETBUFFERPOINTERVARBPROC_HPP)(GLenum target,GLenum pname,GLvoid* *params);

static inline void GetBufferPointervARB(GLenum target,GLenum pname,GLvoid* *params)
{
	static PFNGETBUFFERPOINTERVARBPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPOINTERVARBPROC_HPP>(_impl::_get_proc_address("glGetBufferPointervARB","GL_ARB_vertex_buffer_object"));
	 fn(target,pname,params);
}
#ifndef GL_ARB_vertex_program

#define GL_ARB_vertex_program
#ifndef GL_COLOR_SUM_ARB
#define GL_COLOR_SUM_ARB                                                0x8458
#endif //GL_COLOR_SUM_ARB
#ifndef GL_MAX_VERTEX_ATTRIBS_ARB
#define GL_MAX_VERTEX_ATTRIBS_ARB                                       0x8869
#endif //GL_MAX_VERTEX_ATTRIBS_ARB
#ifndef GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB
#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB                           0x886A
#endif //GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB

#endif //GL_ARB_vertex_program


typedef void (*PFNVERTEXATTRIB1DARBPROC_HPP)(GLuint index,GLdouble x);

static inline void VertexAttrib1dARB(GLuint index,GLdouble x)
{
	static PFNVERTEXATTRIB1DARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1dARB","GL_ARB_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1DVARBPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib1dvARB(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB1DVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1dvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1FARBPROC_HPP)(GLuint index,GLfloat x);

static inline void VertexAttrib1fARB(GLuint index,GLfloat x)
{
	static PFNVERTEXATTRIB1FARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1fARB","GL_ARB_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1FVARBPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib1fvARB(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB1FVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1fvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1SARBPROC_HPP)(GLuint index,GLshort x);

static inline void VertexAttrib1sARB(GLuint index,GLshort x)
{
	static PFNVERTEXATTRIB1SARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1sARB","GL_ARB_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1SVARBPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib1svARB(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB1SVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1svARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2DARBPROC_HPP)(GLuint index,GLdouble x,GLdouble y);

static inline void VertexAttrib2dARB(GLuint index,GLdouble x,GLdouble y)
{
	static PFNVERTEXATTRIB2DARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2dARB","GL_ARB_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2DVARBPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib2dvARB(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB2DVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2dvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2FARBPROC_HPP)(GLuint index,GLfloat x,GLfloat y);

static inline void VertexAttrib2fARB(GLuint index,GLfloat x,GLfloat y)
{
	static PFNVERTEXATTRIB2FARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2fARB","GL_ARB_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2FVARBPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib2fvARB(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB2FVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2fvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2SARBPROC_HPP)(GLuint index,GLshort x,GLshort y);

static inline void VertexAttrib2sARB(GLuint index,GLshort x,GLshort y)
{
	static PFNVERTEXATTRIB2SARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2sARB","GL_ARB_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2SVARBPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib2svARB(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB2SVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2svARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3DARBPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexAttrib3dARB(GLuint index,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXATTRIB3DARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3dARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3DVARBPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib3dvARB(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB3DVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3dvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3FARBPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z);

static inline void VertexAttrib3fARB(GLuint index,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNVERTEXATTRIB3FARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3fARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3FVARBPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib3fvARB(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB3FVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3fvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3SARBPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z);

static inline void VertexAttrib3sARB(GLuint index,GLshort x,GLshort y,GLshort z)
{
	static PFNVERTEXATTRIB3SARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3sARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3SVARBPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib3svARB(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB3SVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3svARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NBVARBPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttrib4NbvARB(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIB4NBVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NBVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NbvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NIVARBPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttrib4NivARB(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIB4NIVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NIVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NivARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NSVARBPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib4NsvARB(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB4NSVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NSVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NsvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUBARBPROC_HPP)(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);

static inline void VertexAttrib4NubARB(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)
{
	static PFNVERTEXATTRIB4NUBARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUBARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NubARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4NUBVARBPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttrib4NubvARB(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIB4NUBVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUBVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NubvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUIVARBPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttrib4NuivARB(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIB4NUIVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUIVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NuivARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4NUSVARBPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttrib4NusvARB(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIB4NUSVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4NUSVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4NusvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4BVARBPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttrib4bvARB(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIB4BVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4BVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4bvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4DARBPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexAttrib4dARB(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXATTRIB4DARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4dARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4DVARBPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib4dvARB(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB4DVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4dvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4FARBPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void VertexAttrib4fARB(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNVERTEXATTRIB4FARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4fARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4FVARBPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib4fvARB(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB4FVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4fvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4IVARBPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttrib4ivARB(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIB4IVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4IVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4ivARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4SARBPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);

static inline void VertexAttrib4sARB(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)
{
	static PFNVERTEXATTRIB4SARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4sARB","GL_ARB_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4SVARBPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib4svARB(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB4SVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4svARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4UBVARBPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttrib4ubvARB(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIB4UBVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UBVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4ubvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4UIVARBPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttrib4uivARB(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIB4UIVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UIVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4uivARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4USVARBPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttrib4usvARB(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIB4USVARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4USVARBPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4usvARB","GL_ARB_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBPOINTERARBPROC_HPP)(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribPointerARB(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBPOINTERARBPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBPOINTERARBPROC_HPP>(_impl::_get_proc_address("glVertexAttribPointerARB","GL_ARB_vertex_program"));
	 fn(index,size,type,normalized,stride,pointer);
}

typedef void (*PFNENABLEVERTEXATTRIBARRAYARBPROC_HPP)(GLuint index);

static inline void EnableVertexAttribArrayARB(GLuint index)
{
	static PFNENABLEVERTEXATTRIBARRAYARBPROC_HPP fn=reinterpret_cast<PFNENABLEVERTEXATTRIBARRAYARBPROC_HPP>(_impl::_get_proc_address("glEnableVertexAttribArrayARB","GL_ARB_vertex_program"));
	 fn(index);
}

typedef void (*PFNDISABLEVERTEXATTRIBARRAYARBPROC_HPP)(GLuint index);

static inline void DisableVertexAttribArrayARB(GLuint index)
{
	static PFNDISABLEVERTEXATTRIBARRAYARBPROC_HPP fn=reinterpret_cast<PFNDISABLEVERTEXATTRIBARRAYARBPROC_HPP>(_impl::_get_proc_address("glDisableVertexAttribArrayARB","GL_ARB_vertex_program"));
	 fn(index);
}

typedef void (*PFNPROGRAMSTRINGARBPROC_HPP)(GLenum target,GLenum format,GLsizei len,const GLvoid *string);

static inline void ProgramStringARB(GLenum target,GLenum format,GLsizei len,const GLvoid *string)
{
	static PFNPROGRAMSTRINGARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMSTRINGARBPROC_HPP>(_impl::_get_proc_address("glProgramStringARB","GL_ARB_vertex_program"));
	 fn(target,format,len,string);
}

typedef void (*PFNBINDPROGRAMARBPROC_HPP)(GLenum target,GLuint program);

static inline void BindProgramARB(GLenum target,GLuint program)
{
	static PFNBINDPROGRAMARBPROC_HPP fn=reinterpret_cast<PFNBINDPROGRAMARBPROC_HPP>(_impl::_get_proc_address("glBindProgramARB","GL_ARB_vertex_program"));
	 fn(target,program);
}

typedef void (*PFNDELETEPROGRAMSARBPROC_HPP)(GLsizei n,const GLuint *programs);

static inline void DeleteProgramsARB(GLsizei n,const GLuint *programs)
{
	static PFNDELETEPROGRAMSARBPROC_HPP fn=reinterpret_cast<PFNDELETEPROGRAMSARBPROC_HPP>(_impl::_get_proc_address("glDeleteProgramsARB","GL_ARB_vertex_program"));
	 fn(n,programs);
}

typedef void (*PFNGENPROGRAMSARBPROC_HPP)(GLsizei n,GLuint *programs);

static inline void GenProgramsARB(GLsizei n,GLuint *programs)
{
	static PFNGENPROGRAMSARBPROC_HPP fn=reinterpret_cast<PFNGENPROGRAMSARBPROC_HPP>(_impl::_get_proc_address("glGenProgramsARB","GL_ARB_vertex_program"));
	 fn(n,programs);
}

typedef void (*PFNPROGRAMENVPARAMETER4DARBPROC_HPP)(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void ProgramEnvParameter4dARB(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNPROGRAMENVPARAMETER4DARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETER4DARBPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameter4dARB","GL_ARB_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMENVPARAMETER4DVARBPROC_HPP)(GLenum target,GLuint index,const GLdouble *params);

static inline void ProgramEnvParameter4dvARB(GLenum target,GLuint index,const GLdouble *params)
{
	static PFNPROGRAMENVPARAMETER4DVARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETER4DVARBPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameter4dvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMENVPARAMETER4FARBPROC_HPP)(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void ProgramEnvParameter4fARB(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNPROGRAMENVPARAMETER4FARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETER4FARBPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameter4fARB","GL_ARB_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMENVPARAMETER4FVARBPROC_HPP)(GLenum target,GLuint index,const GLfloat *params);

static inline void ProgramEnvParameter4fvARB(GLenum target,GLuint index,const GLfloat *params)
{
	static PFNPROGRAMENVPARAMETER4FVARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETER4FVARBPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameter4fvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETER4DARBPROC_HPP)(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void ProgramLocalParameter4dARB(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNPROGRAMLOCALPARAMETER4DARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETER4DARBPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameter4dARB","GL_ARB_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMLOCALPARAMETER4DVARBPROC_HPP)(GLenum target,GLuint index,const GLdouble *params);

static inline void ProgramLocalParameter4dvARB(GLenum target,GLuint index,const GLdouble *params)
{
	static PFNPROGRAMLOCALPARAMETER4DVARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETER4DVARBPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameter4dvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETER4FARBPROC_HPP)(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void ProgramLocalParameter4fARB(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNPROGRAMLOCALPARAMETER4FARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETER4FARBPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameter4fARB","GL_ARB_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMLOCALPARAMETER4FVARBPROC_HPP)(GLenum target,GLuint index,const GLfloat *params);

static inline void ProgramLocalParameter4fvARB(GLenum target,GLuint index,const GLfloat *params)
{
	static PFNPROGRAMLOCALPARAMETER4FVARBPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETER4FVARBPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameter4fvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMENVPARAMETERDVARBPROC_HPP)(GLenum target,GLuint index,GLdouble *params);

static inline void GetProgramEnvParameterdvARB(GLenum target,GLuint index,GLdouble *params)
{
	static PFNGETPROGRAMENVPARAMETERDVARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMENVPARAMETERDVARBPROC_HPP>(_impl::_get_proc_address("glGetProgramEnvParameterdvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMENVPARAMETERFVARBPROC_HPP)(GLenum target,GLuint index,GLfloat *params);

static inline void GetProgramEnvParameterfvARB(GLenum target,GLuint index,GLfloat *params)
{
	static PFNGETPROGRAMENVPARAMETERFVARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMENVPARAMETERFVARBPROC_HPP>(_impl::_get_proc_address("glGetProgramEnvParameterfvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMLOCALPARAMETERDVARBPROC_HPP)(GLenum target,GLuint index,GLdouble *params);

static inline void GetProgramLocalParameterdvARB(GLenum target,GLuint index,GLdouble *params)
{
	static PFNGETPROGRAMLOCALPARAMETERDVARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMLOCALPARAMETERDVARBPROC_HPP>(_impl::_get_proc_address("glGetProgramLocalParameterdvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMLOCALPARAMETERFVARBPROC_HPP)(GLenum target,GLuint index,GLfloat *params);

static inline void GetProgramLocalParameterfvARB(GLenum target,GLuint index,GLfloat *params)
{
	static PFNGETPROGRAMLOCALPARAMETERFVARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMLOCALPARAMETERFVARBPROC_HPP>(_impl::_get_proc_address("glGetProgramLocalParameterfvARB","GL_ARB_vertex_program"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMIVARBPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetProgramivARB(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETPROGRAMIVARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMIVARBPROC_HPP>(_impl::_get_proc_address("glGetProgramivARB","GL_ARB_vertex_program"));
	 fn(target,pname,params);
}

typedef void (*PFNGETPROGRAMSTRINGARBPROC_HPP)(GLenum target,GLenum pname,GLvoid *string);

static inline void GetProgramStringARB(GLenum target,GLenum pname,GLvoid *string)
{
	static PFNGETPROGRAMSTRINGARBPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMSTRINGARBPROC_HPP>(_impl::_get_proc_address("glGetProgramStringARB","GL_ARB_vertex_program"));
	 fn(target,pname,string);
}

typedef void (*PFNGETVERTEXATTRIBDVARBPROC_HPP)(GLuint index,GLenum pname,GLdouble *params);

static inline void GetVertexAttribdvARB(GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETVERTEXATTRIBDVARBPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBDVARBPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribdvARB","GL_ARB_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBFVARBPROC_HPP)(GLuint index,GLenum pname,GLfloat *params);

static inline void GetVertexAttribfvARB(GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETVERTEXATTRIBFVARBPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBFVARBPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribfvARB","GL_ARB_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBIVARBPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribivARB(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBIVARBPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIVARBPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribivARB","GL_ARB_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBPOINTERVARBPROC_HPP)(GLuint index,GLenum pname,GLvoid* *pointer);

static inline void GetVertexAttribPointervARB(GLuint index,GLenum pname,GLvoid* *pointer)
{
	static PFNGETVERTEXATTRIBPOINTERVARBPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBPOINTERVARBPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribPointervARB","GL_ARB_vertex_program"));
	 fn(index,pname,pointer);
}

typedef GLboolean (*PFNISPROGRAMARBPROC_HPP)(GLuint program);

static inline GLboolean IsProgramARB(GLuint program)
{
	static PFNISPROGRAMARBPROC_HPP fn=reinterpret_cast<PFNISPROGRAMARBPROC_HPP>(_impl::_get_proc_address("glIsProgramARB","GL_ARB_vertex_program"));
	return fn(program);
}
#ifndef GL_ARB_vertex_shader

#define GL_ARB_vertex_shader

#endif //GL_ARB_vertex_shader


typedef void (*PFNBINDATTRIBLOCATIONARBPROC_HPP)(GLhandleARB programObj,GLuint index,const GLcharARB *name);

static inline void BindAttribLocationARB(GLhandleARB programObj,GLuint index,const GLcharARB *name)
{
	static PFNBINDATTRIBLOCATIONARBPROC_HPP fn=reinterpret_cast<PFNBINDATTRIBLOCATIONARBPROC_HPP>(_impl::_get_proc_address("glBindAttribLocationARB","GL_ARB_vertex_shader"));
	 fn(programObj,index,name);
}

typedef void (*PFNGETACTIVEATTRIBARBPROC_HPP)(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei *length,GLint *size,GLenum *type,GLcharARB *name);

static inline void GetActiveAttribARB(GLhandleARB programObj,GLuint index,GLsizei maxLength,GLsizei *length,GLint *size,GLenum *type,GLcharARB *name)
{
	static PFNGETACTIVEATTRIBARBPROC_HPP fn=reinterpret_cast<PFNGETACTIVEATTRIBARBPROC_HPP>(_impl::_get_proc_address("glGetActiveAttribARB","GL_ARB_vertex_shader"));
	 fn(programObj,index,maxLength,length,size,type,name);
}

typedef GLint (*PFNGETATTRIBLOCATIONARBPROC_HPP)(GLhandleARB programObj,const GLcharARB *name);

static inline GLint GetAttribLocationARB(GLhandleARB programObj,const GLcharARB *name)
{
	static PFNGETATTRIBLOCATIONARBPROC_HPP fn=reinterpret_cast<PFNGETATTRIBLOCATIONARBPROC_HPP>(_impl::_get_proc_address("glGetAttribLocationARB","GL_ARB_vertex_shader"));
	return fn(programObj,name);
}
#ifndef GL_ARB_vertex_type_2_10_10_10_rev

#define GL_ARB_vertex_type_2_10_10_10_rev
#ifndef GL_INT_2_10_10_10_REV
#define GL_INT_2_10_10_10_REV                                           0x8D9F
#endif //GL_INT_2_10_10_10_REV

#endif //GL_ARB_vertex_type_2_10_10_10_rev


typedef void (*PFNVERTEXP2UIPROC_HPP)(GLenum type,GLuint value);

static inline void VertexP2ui(GLenum type,GLuint value)
{
	static PFNVERTEXP2UIPROC_HPP fn=reinterpret_cast<PFNVERTEXP2UIPROC_HPP>(_impl::_get_proc_address("glVertexP2ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNVERTEXP2UIVPROC_HPP)(GLenum type,const GLuint *value);

static inline void VertexP2uiv(GLenum type,const GLuint *value)
{
	static PFNVERTEXP2UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXP2UIVPROC_HPP>(_impl::_get_proc_address("glVertexP2uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNVERTEXP3UIPROC_HPP)(GLenum type,GLuint value);

static inline void VertexP3ui(GLenum type,GLuint value)
{
	static PFNVERTEXP3UIPROC_HPP fn=reinterpret_cast<PFNVERTEXP3UIPROC_HPP>(_impl::_get_proc_address("glVertexP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNVERTEXP3UIVPROC_HPP)(GLenum type,const GLuint *value);

static inline void VertexP3uiv(GLenum type,const GLuint *value)
{
	static PFNVERTEXP3UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXP3UIVPROC_HPP>(_impl::_get_proc_address("glVertexP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNVERTEXP4UIPROC_HPP)(GLenum type,GLuint value);

static inline void VertexP4ui(GLenum type,GLuint value)
{
	static PFNVERTEXP4UIPROC_HPP fn=reinterpret_cast<PFNVERTEXP4UIPROC_HPP>(_impl::_get_proc_address("glVertexP4ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNVERTEXP4UIVPROC_HPP)(GLenum type,const GLuint *value);

static inline void VertexP4uiv(GLenum type,const GLuint *value)
{
	static PFNVERTEXP4UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXP4UIVPROC_HPP>(_impl::_get_proc_address("glVertexP4uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,value);
}

typedef void (*PFNTEXCOORDP1UIPROC_HPP)(GLenum type,GLuint coords);

static inline void TexCoordP1ui(GLenum type,GLuint coords)
{
	static PFNTEXCOORDP1UIPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP1UIPROC_HPP>(_impl::_get_proc_address("glTexCoordP1ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP1UIVPROC_HPP)(GLenum type,const GLuint *coords);

static inline void TexCoordP1uiv(GLenum type,const GLuint *coords)
{
	static PFNTEXCOORDP1UIVPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP1UIVPROC_HPP>(_impl::_get_proc_address("glTexCoordP1uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP2UIPROC_HPP)(GLenum type,GLuint coords);

static inline void TexCoordP2ui(GLenum type,GLuint coords)
{
	static PFNTEXCOORDP2UIPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP2UIPROC_HPP>(_impl::_get_proc_address("glTexCoordP2ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP2UIVPROC_HPP)(GLenum type,const GLuint *coords);

static inline void TexCoordP2uiv(GLenum type,const GLuint *coords)
{
	static PFNTEXCOORDP2UIVPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP2UIVPROC_HPP>(_impl::_get_proc_address("glTexCoordP2uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP3UIPROC_HPP)(GLenum type,GLuint coords);

static inline void TexCoordP3ui(GLenum type,GLuint coords)
{
	static PFNTEXCOORDP3UIPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP3UIPROC_HPP>(_impl::_get_proc_address("glTexCoordP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP3UIVPROC_HPP)(GLenum type,const GLuint *coords);

static inline void TexCoordP3uiv(GLenum type,const GLuint *coords)
{
	static PFNTEXCOORDP3UIVPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP3UIVPROC_HPP>(_impl::_get_proc_address("glTexCoordP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP4UIPROC_HPP)(GLenum type,GLuint coords);

static inline void TexCoordP4ui(GLenum type,GLuint coords)
{
	static PFNTEXCOORDP4UIPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP4UIPROC_HPP>(_impl::_get_proc_address("glTexCoordP4ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNTEXCOORDP4UIVPROC_HPP)(GLenum type,const GLuint *coords);

static inline void TexCoordP4uiv(GLenum type,const GLuint *coords)
{
	static PFNTEXCOORDP4UIVPROC_HPP fn=reinterpret_cast<PFNTEXCOORDP4UIVPROC_HPP>(_impl::_get_proc_address("glTexCoordP4uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNMULTITEXCOORDP1UIPROC_HPP)(GLenum texture,GLenum type,GLuint coords);

static inline void MultiTexCoordP1ui(GLenum texture,GLenum type,GLuint coords)
{
	static PFNMULTITEXCOORDP1UIPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP1UIPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP1ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP1UIVPROC_HPP)(GLenum texture,GLenum type,const GLuint *coords);

static inline void MultiTexCoordP1uiv(GLenum texture,GLenum type,const GLuint *coords)
{
	static PFNMULTITEXCOORDP1UIVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP1UIVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP1uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP2UIPROC_HPP)(GLenum texture,GLenum type,GLuint coords);

static inline void MultiTexCoordP2ui(GLenum texture,GLenum type,GLuint coords)
{
	static PFNMULTITEXCOORDP2UIPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP2UIPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP2ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP2UIVPROC_HPP)(GLenum texture,GLenum type,const GLuint *coords);

static inline void MultiTexCoordP2uiv(GLenum texture,GLenum type,const GLuint *coords)
{
	static PFNMULTITEXCOORDP2UIVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP2UIVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP2uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP3UIPROC_HPP)(GLenum texture,GLenum type,GLuint coords);

static inline void MultiTexCoordP3ui(GLenum texture,GLenum type,GLuint coords)
{
	static PFNMULTITEXCOORDP3UIPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP3UIPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP3UIVPROC_HPP)(GLenum texture,GLenum type,const GLuint *coords);

static inline void MultiTexCoordP3uiv(GLenum texture,GLenum type,const GLuint *coords)
{
	static PFNMULTITEXCOORDP3UIVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP3UIVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP4UIPROC_HPP)(GLenum texture,GLenum type,GLuint coords);

static inline void MultiTexCoordP4ui(GLenum texture,GLenum type,GLuint coords)
{
	static PFNMULTITEXCOORDP4UIPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP4UIPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP4ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNMULTITEXCOORDP4UIVPROC_HPP)(GLenum texture,GLenum type,const GLuint *coords);

static inline void MultiTexCoordP4uiv(GLenum texture,GLenum type,const GLuint *coords)
{
	static PFNMULTITEXCOORDP4UIVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDP4UIVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordP4uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(texture,type,coords);
}

typedef void (*PFNNORMALP3UIPROC_HPP)(GLenum type,GLuint coords);

static inline void NormalP3ui(GLenum type,GLuint coords)
{
	static PFNNORMALP3UIPROC_HPP fn=reinterpret_cast<PFNNORMALP3UIPROC_HPP>(_impl::_get_proc_address("glNormalP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNNORMALP3UIVPROC_HPP)(GLenum type,const GLuint *coords);

static inline void NormalP3uiv(GLenum type,const GLuint *coords)
{
	static PFNNORMALP3UIVPROC_HPP fn=reinterpret_cast<PFNNORMALP3UIVPROC_HPP>(_impl::_get_proc_address("glNormalP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,coords);
}

typedef void (*PFNCOLORP3UIPROC_HPP)(GLenum type,GLuint color);

static inline void ColorP3ui(GLenum type,GLuint color)
{
	static PFNCOLORP3UIPROC_HPP fn=reinterpret_cast<PFNCOLORP3UIPROC_HPP>(_impl::_get_proc_address("glColorP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNCOLORP3UIVPROC_HPP)(GLenum type,const GLuint *color);

static inline void ColorP3uiv(GLenum type,const GLuint *color)
{
	static PFNCOLORP3UIVPROC_HPP fn=reinterpret_cast<PFNCOLORP3UIVPROC_HPP>(_impl::_get_proc_address("glColorP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNCOLORP4UIPROC_HPP)(GLenum type,GLuint color);

static inline void ColorP4ui(GLenum type,GLuint color)
{
	static PFNCOLORP4UIPROC_HPP fn=reinterpret_cast<PFNCOLORP4UIPROC_HPP>(_impl::_get_proc_address("glColorP4ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNCOLORP4UIVPROC_HPP)(GLenum type,const GLuint *color);

static inline void ColorP4uiv(GLenum type,const GLuint *color)
{
	static PFNCOLORP4UIVPROC_HPP fn=reinterpret_cast<PFNCOLORP4UIVPROC_HPP>(_impl::_get_proc_address("glColorP4uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNSECONDARYCOLORP3UIPROC_HPP)(GLenum type,GLuint color);

static inline void SecondaryColorP3ui(GLenum type,GLuint color)
{
	static PFNSECONDARYCOLORP3UIPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORP3UIPROC_HPP>(_impl::_get_proc_address("glSecondaryColorP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNSECONDARYCOLORP3UIVPROC_HPP)(GLenum type,const GLuint *color);

static inline void SecondaryColorP3uiv(GLenum type,const GLuint *color)
{
	static PFNSECONDARYCOLORP3UIVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORP3UIVPROC_HPP>(_impl::_get_proc_address("glSecondaryColorP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(type,color);
}

typedef void (*PFNVERTEXATTRIBP1UIPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,GLuint value);

static inline void VertexAttribP1ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)
{
	static PFNVERTEXATTRIBP1UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP1UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribP1ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP1UIVPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,const GLuint *value);

static inline void VertexAttribP1uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint *value)
{
	static PFNVERTEXATTRIBP1UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP1UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribP1uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP2UIPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,GLuint value);

static inline void VertexAttribP2ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)
{
	static PFNVERTEXATTRIBP2UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP2UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribP2ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP2UIVPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,const GLuint *value);

static inline void VertexAttribP2uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint *value)
{
	static PFNVERTEXATTRIBP2UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP2UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribP2uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP3UIPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,GLuint value);

static inline void VertexAttribP3ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)
{
	static PFNVERTEXATTRIBP3UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP3UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribP3ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP3UIVPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,const GLuint *value);

static inline void VertexAttribP3uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint *value)
{
	static PFNVERTEXATTRIBP3UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP3UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribP3uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP4UIPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,GLuint value);

static inline void VertexAttribP4ui(GLuint index,GLenum type,GLboolean normalized,GLuint value)
{
	static PFNVERTEXATTRIBP4UIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP4UIPROC_HPP>(_impl::_get_proc_address("glVertexAttribP4ui","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}

typedef void (*PFNVERTEXATTRIBP4UIVPROC_HPP)(GLuint index,GLenum type,GLboolean normalized,const GLuint *value);

static inline void VertexAttribP4uiv(GLuint index,GLenum type,GLboolean normalized,const GLuint *value)
{
	static PFNVERTEXATTRIBP4UIVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBP4UIVPROC_HPP>(_impl::_get_proc_address("glVertexAttribP4uiv","GL_ARB_vertex_type_2_10_10_10_rev"));
	 fn(index,type,normalized,value);
}
#ifndef GL_ARB_viewport_array

#define GL_ARB_viewport_array
#ifndef GL_MAX_VIEWPORTS
#define GL_MAX_VIEWPORTS                                                0x825B
#endif //GL_MAX_VIEWPORTS
#ifndef GL_VIEWPORT_SUBPIXEL_BITS
#define GL_VIEWPORT_SUBPIXEL_BITS                                       0x825C
#endif //GL_VIEWPORT_SUBPIXEL_BITS
#ifndef GL_VIEWPORT_BOUNDS_RANGE
#define GL_VIEWPORT_BOUNDS_RANGE                                        0x825D
#endif //GL_VIEWPORT_BOUNDS_RANGE
#ifndef GL_LAYER_PROVOKING_VERTEX
#define GL_LAYER_PROVOKING_VERTEX                                       0x825E
#endif //GL_LAYER_PROVOKING_VERTEX
#ifndef GL_VIEWPORT_INDEX_PROVOKING_VERTEX
#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX                              0x825F
#endif //GL_VIEWPORT_INDEX_PROVOKING_VERTEX
#ifndef GL_UNDEFINED_VERTEX
#define GL_UNDEFINED_VERTEX                                             0x8260
#endif //GL_UNDEFINED_VERTEX

#endif //GL_ARB_viewport_array


typedef void (*PFNVIEWPORTARRAYVPROC_HPP)(GLuint first,GLsizei count,const GLfloat *v);

static inline void ViewportArrayv(GLuint first,GLsizei count,const GLfloat *v)
{
	static PFNVIEWPORTARRAYVPROC_HPP fn=reinterpret_cast<PFNVIEWPORTARRAYVPROC_HPP>(_impl::_get_proc_address("glViewportArrayv","GL_ARB_viewport_array"));
	 fn(first,count,v);
}

typedef void (*PFNVIEWPORTINDEXEDFPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat w,GLfloat h);

static inline void ViewportIndexedf(GLuint index,GLfloat x,GLfloat y,GLfloat w,GLfloat h)
{
	static PFNVIEWPORTINDEXEDFPROC_HPP fn=reinterpret_cast<PFNVIEWPORTINDEXEDFPROC_HPP>(_impl::_get_proc_address("glViewportIndexedf","GL_ARB_viewport_array"));
	 fn(index,x,y,w,h);
}

typedef void (*PFNVIEWPORTINDEXEDFVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void ViewportIndexedfv(GLuint index,const GLfloat *v)
{
	static PFNVIEWPORTINDEXEDFVPROC_HPP fn=reinterpret_cast<PFNVIEWPORTINDEXEDFVPROC_HPP>(_impl::_get_proc_address("glViewportIndexedfv","GL_ARB_viewport_array"));
	 fn(index,v);
}

typedef void (*PFNSCISSORARRAYVPROC_HPP)(GLuint first,GLsizei count,const GLint *v);

static inline void ScissorArrayv(GLuint first,GLsizei count,const GLint *v)
{
	static PFNSCISSORARRAYVPROC_HPP fn=reinterpret_cast<PFNSCISSORARRAYVPROC_HPP>(_impl::_get_proc_address("glScissorArrayv","GL_ARB_viewport_array"));
	 fn(first,count,v);
}

typedef void (*PFNSCISSORINDEXEDPROC_HPP)(GLuint index,GLint left,GLint bottom,GLsizei width,GLsizei height);

static inline void ScissorIndexed(GLuint index,GLint left,GLint bottom,GLsizei width,GLsizei height)
{
	static PFNSCISSORINDEXEDPROC_HPP fn=reinterpret_cast<PFNSCISSORINDEXEDPROC_HPP>(_impl::_get_proc_address("glScissorIndexed","GL_ARB_viewport_array"));
	 fn(index,left,bottom,width,height);
}

typedef void (*PFNSCISSORINDEXEDVPROC_HPP)(GLuint index,const GLint *v);

static inline void ScissorIndexedv(GLuint index,const GLint *v)
{
	static PFNSCISSORINDEXEDVPROC_HPP fn=reinterpret_cast<PFNSCISSORINDEXEDVPROC_HPP>(_impl::_get_proc_address("glScissorIndexedv","GL_ARB_viewport_array"));
	 fn(index,v);
}

typedef void (*PFNDEPTHRANGEARRAYVPROC_HPP)(GLuint first,GLsizei count,const GLdouble *v);

static inline void DepthRangeArrayv(GLuint first,GLsizei count,const GLdouble *v)
{
	static PFNDEPTHRANGEARRAYVPROC_HPP fn=reinterpret_cast<PFNDEPTHRANGEARRAYVPROC_HPP>(_impl::_get_proc_address("glDepthRangeArrayv","GL_ARB_viewport_array"));
	 fn(first,count,v);
}

typedef void (*PFNDEPTHRANGEINDEXEDPROC_HPP)(GLuint index,GLdouble n,GLdouble f);

static inline void DepthRangeIndexed(GLuint index,GLdouble n,GLdouble f)
{
	static PFNDEPTHRANGEINDEXEDPROC_HPP fn=reinterpret_cast<PFNDEPTHRANGEINDEXEDPROC_HPP>(_impl::_get_proc_address("glDepthRangeIndexed","GL_ARB_viewport_array"));
	 fn(index,n,f);
}

typedef void (*PFNGETFLOATI_VPROC_HPP)(GLenum target,GLuint index,GLfloat *data);

static inline void GetFloati_v(GLenum target,GLuint index,GLfloat *data)
{
	static PFNGETFLOATI_VPROC_HPP fn=reinterpret_cast<PFNGETFLOATI_VPROC_HPP>(_impl::_get_proc_address("glGetFloati_v","GL_ARB_viewport_array"));
	 fn(target,index,data);
}

typedef void (*PFNGETDOUBLEI_VPROC_HPP)(GLenum target,GLuint index,GLdouble *data);

static inline void GetDoublei_v(GLenum target,GLuint index,GLdouble *data)
{
	static PFNGETDOUBLEI_VPROC_HPP fn=reinterpret_cast<PFNGETDOUBLEI_VPROC_HPP>(_impl::_get_proc_address("glGetDoublei_v","GL_ARB_viewport_array"));
	 fn(target,index,data);
}
#ifndef GL_ARB_window_pos

#define GL_ARB_window_pos

#endif //GL_ARB_window_pos


typedef void (*PFNWINDOWPOS2DARBPROC_HPP)(GLdouble x,GLdouble y);

static inline void WindowPos2dARB(GLdouble x,GLdouble y)
{
	static PFNWINDOWPOS2DARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2dARB","GL_ARB_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2DVARBPROC_HPP)(const GLdouble *v);

static inline void WindowPos2dvARB(const GLdouble *v)
{
	static PFNWINDOWPOS2DVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2dvARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2FARBPROC_HPP)(GLfloat x,GLfloat y);

static inline void WindowPos2fARB(GLfloat x,GLfloat y)
{
	static PFNWINDOWPOS2FARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2fARB","GL_ARB_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2FVARBPROC_HPP)(const GLfloat *v);

static inline void WindowPos2fvARB(const GLfloat *v)
{
	static PFNWINDOWPOS2FVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2fvARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2IARBPROC_HPP)(GLint x,GLint y);

static inline void WindowPos2iARB(GLint x,GLint y)
{
	static PFNWINDOWPOS2IARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2iARB","GL_ARB_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2IVARBPROC_HPP)(const GLint *v);

static inline void WindowPos2ivARB(const GLint *v)
{
	static PFNWINDOWPOS2IVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2ivARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2SARBPROC_HPP)(GLshort x,GLshort y);

static inline void WindowPos2sARB(GLshort x,GLshort y)
{
	static PFNWINDOWPOS2SARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2sARB","GL_ARB_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2SVARBPROC_HPP)(const GLshort *v);

static inline void WindowPos2svARB(const GLshort *v)
{
	static PFNWINDOWPOS2SVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos2svARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3DARBPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

static inline void WindowPos3dARB(GLdouble x,GLdouble y,GLdouble z)
{
	static PFNWINDOWPOS3DARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3dARB","GL_ARB_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3DVARBPROC_HPP)(const GLdouble *v);

static inline void WindowPos3dvARB(const GLdouble *v)
{
	static PFNWINDOWPOS3DVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3dvARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3FARBPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

static inline void WindowPos3fARB(GLfloat x,GLfloat y,GLfloat z)
{
	static PFNWINDOWPOS3FARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3fARB","GL_ARB_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3FVARBPROC_HPP)(const GLfloat *v);

static inline void WindowPos3fvARB(const GLfloat *v)
{
	static PFNWINDOWPOS3FVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3fvARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3IARBPROC_HPP)(GLint x,GLint y,GLint z);

static inline void WindowPos3iARB(GLint x,GLint y,GLint z)
{
	static PFNWINDOWPOS3IARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3iARB","GL_ARB_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3IVARBPROC_HPP)(const GLint *v);

static inline void WindowPos3ivARB(const GLint *v)
{
	static PFNWINDOWPOS3IVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3ivARB","GL_ARB_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3SARBPROC_HPP)(GLshort x,GLshort y,GLshort z);

static inline void WindowPos3sARB(GLshort x,GLshort y,GLshort z)
{
	static PFNWINDOWPOS3SARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3sARB","GL_ARB_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3SVARBPROC_HPP)(const GLshort *v);

static inline void WindowPos3svARB(const GLshort *v)
{
	static PFNWINDOWPOS3SVARBPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SVARBPROC_HPP>(_impl::_get_proc_address("glWindowPos3svARB","GL_ARB_window_pos"));
	 fn(v);
}
#ifndef GL_ARM_mali_shader_binary

#define GL_ARM_mali_shader_binary
#ifndef GL_MALI_SHADER_BINARY_ARM
#define GL_MALI_SHADER_BINARY_ARM                                       0x8F60
#endif //GL_MALI_SHADER_BINARY_ARM

#endif //GL_ARM_mali_shader_binary

#ifndef GL_ATI_draw_buffers

#define GL_ATI_draw_buffers
#ifndef GL_MAX_DRAW_BUFFERS_ATI
#define GL_MAX_DRAW_BUFFERS_ATI                                         0x8824
#endif //GL_MAX_DRAW_BUFFERS_ATI
#ifndef GL_DRAW_BUFFER0_ATI
#define GL_DRAW_BUFFER0_ATI                                             0x8825
#endif //GL_DRAW_BUFFER0_ATI
#ifndef GL_DRAW_BUFFER1_ATI
#define GL_DRAW_BUFFER1_ATI                                             0x8826
#endif //GL_DRAW_BUFFER1_ATI
#ifndef GL_DRAW_BUFFER2_ATI
#define GL_DRAW_BUFFER2_ATI                                             0x8827
#endif //GL_DRAW_BUFFER2_ATI
#ifndef GL_DRAW_BUFFER3_ATI
#define GL_DRAW_BUFFER3_ATI                                             0x8828
#endif //GL_DRAW_BUFFER3_ATI
#ifndef GL_DRAW_BUFFER4_ATI
#define GL_DRAW_BUFFER4_ATI                                             0x8829
#endif //GL_DRAW_BUFFER4_ATI
#ifndef GL_DRAW_BUFFER5_ATI
#define GL_DRAW_BUFFER5_ATI                                             0x882A
#endif //GL_DRAW_BUFFER5_ATI
#ifndef GL_DRAW_BUFFER6_ATI
#define GL_DRAW_BUFFER6_ATI                                             0x882B
#endif //GL_DRAW_BUFFER6_ATI
#ifndef GL_DRAW_BUFFER7_ATI
#define GL_DRAW_BUFFER7_ATI                                             0x882C
#endif //GL_DRAW_BUFFER7_ATI
#ifndef GL_DRAW_BUFFER8_ATI
#define GL_DRAW_BUFFER8_ATI                                             0x882D
#endif //GL_DRAW_BUFFER8_ATI
#ifndef GL_DRAW_BUFFER9_ATI
#define GL_DRAW_BUFFER9_ATI                                             0x882E
#endif //GL_DRAW_BUFFER9_ATI
#ifndef GL_DRAW_BUFFER10_ATI
#define GL_DRAW_BUFFER10_ATI                                            0x882F
#endif //GL_DRAW_BUFFER10_ATI
#ifndef GL_DRAW_BUFFER11_ATI
#define GL_DRAW_BUFFER11_ATI                                            0x8830
#endif //GL_DRAW_BUFFER11_ATI
#ifndef GL_DRAW_BUFFER12_ATI
#define GL_DRAW_BUFFER12_ATI                                            0x8831
#endif //GL_DRAW_BUFFER12_ATI
#ifndef GL_DRAW_BUFFER13_ATI
#define GL_DRAW_BUFFER13_ATI                                            0x8832
#endif //GL_DRAW_BUFFER13_ATI
#ifndef GL_DRAW_BUFFER14_ATI
#define GL_DRAW_BUFFER14_ATI                                            0x8833
#endif //GL_DRAW_BUFFER14_ATI
#ifndef GL_DRAW_BUFFER15_ATI
#define GL_DRAW_BUFFER15_ATI                                            0x8834
#endif //GL_DRAW_BUFFER15_ATI

#endif //GL_ATI_draw_buffers


typedef void (*PFNDRAWBUFFERSATIPROC_HPP)(GLsizei n,const GLenum *bufs);

static inline void DrawBuffersATI(GLsizei n,const GLenum *bufs)
{
	static PFNDRAWBUFFERSATIPROC_HPP fn=reinterpret_cast<PFNDRAWBUFFERSATIPROC_HPP>(_impl::_get_proc_address("glDrawBuffersATI","GL_ATI_draw_buffers"));
	 fn(n,bufs);
}
#ifndef GL_ATI_element_array

#define GL_ATI_element_array
#ifndef GL_ELEMENT_ARRAY_ATI
#define GL_ELEMENT_ARRAY_ATI                                            0x8768
#endif //GL_ELEMENT_ARRAY_ATI
#ifndef GL_ELEMENT_ARRAY_TYPE_ATI
#define GL_ELEMENT_ARRAY_TYPE_ATI                                       0x8769
#endif //GL_ELEMENT_ARRAY_TYPE_ATI
#ifndef GL_ELEMENT_ARRAY_POINTER_ATI
#define GL_ELEMENT_ARRAY_POINTER_ATI                                    0x876A
#endif //GL_ELEMENT_ARRAY_POINTER_ATI

#endif //GL_ATI_element_array


typedef void (*PFNELEMENTPOINTERATIPROC_HPP)(GLenum type,const GLvoid *pointer);

static inline void ElementPointerATI(GLenum type,const GLvoid *pointer)
{
	static PFNELEMENTPOINTERATIPROC_HPP fn=reinterpret_cast<PFNELEMENTPOINTERATIPROC_HPP>(_impl::_get_proc_address("glElementPointerATI","GL_ATI_element_array"));
	 fn(type,pointer);
}

typedef void (*PFNDRAWELEMENTARRAYATIPROC_HPP)(GLenum mode,GLsizei count);

static inline void DrawElementArrayATI(GLenum mode,GLsizei count)
{
	static PFNDRAWELEMENTARRAYATIPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTARRAYATIPROC_HPP>(_impl::_get_proc_address("glDrawElementArrayATI","GL_ATI_element_array"));
	 fn(mode,count);
}

typedef void (*PFNDRAWRANGEELEMENTARRAYATIPROC_HPP)(GLenum mode,GLuint start,GLuint end,GLsizei count);

static inline void DrawRangeElementArrayATI(GLenum mode,GLuint start,GLuint end,GLsizei count)
{
	static PFNDRAWRANGEELEMENTARRAYATIPROC_HPP fn=reinterpret_cast<PFNDRAWRANGEELEMENTARRAYATIPROC_HPP>(_impl::_get_proc_address("glDrawRangeElementArrayATI","GL_ATI_element_array"));
	 fn(mode,start,end,count);
}
#ifndef GL_ATI_envmap_bumpmap

#define GL_ATI_envmap_bumpmap
#ifndef GL_BUMP_ROT_MATRIX_ATI
#define GL_BUMP_ROT_MATRIX_ATI                                          0x8775
#endif //GL_BUMP_ROT_MATRIX_ATI
#ifndef GL_BUMP_ROT_MATRIX_SIZE_ATI
#define GL_BUMP_ROT_MATRIX_SIZE_ATI                                     0x8776
#endif //GL_BUMP_ROT_MATRIX_SIZE_ATI
#ifndef GL_BUMP_NUM_TEX_UNITS_ATI
#define GL_BUMP_NUM_TEX_UNITS_ATI                                       0x8777
#endif //GL_BUMP_NUM_TEX_UNITS_ATI
#ifndef GL_BUMP_TEX_UNITS_ATI
#define GL_BUMP_TEX_UNITS_ATI                                           0x8778
#endif //GL_BUMP_TEX_UNITS_ATI
#ifndef GL_DUDV_ATI
#define GL_DUDV_ATI                                                     0x8779
#endif //GL_DUDV_ATI
#ifndef GL_DU8DV8_ATI
#define GL_DU8DV8_ATI                                                   0x877A
#endif //GL_DU8DV8_ATI
#ifndef GL_BUMP_ENVMAP_ATI
#define GL_BUMP_ENVMAP_ATI                                              0x877B
#endif //GL_BUMP_ENVMAP_ATI
#ifndef GL_BUMP_TARGET_ATI
#define GL_BUMP_TARGET_ATI                                              0x877C
#endif //GL_BUMP_TARGET_ATI

#endif //GL_ATI_envmap_bumpmap


typedef void (*PFNTEXBUMPPARAMETERIVATIPROC_HPP)(GLenum pname,const GLint *param);

static inline void TexBumpParameterivATI(GLenum pname,const GLint *param)
{
	static PFNTEXBUMPPARAMETERIVATIPROC_HPP fn=reinterpret_cast<PFNTEXBUMPPARAMETERIVATIPROC_HPP>(_impl::_get_proc_address("glTexBumpParameterivATI","GL_ATI_envmap_bumpmap"));
	 fn(pname,param);
}

typedef void (*PFNTEXBUMPPARAMETERFVATIPROC_HPP)(GLenum pname,const GLfloat *param);

static inline void TexBumpParameterfvATI(GLenum pname,const GLfloat *param)
{
	static PFNTEXBUMPPARAMETERFVATIPROC_HPP fn=reinterpret_cast<PFNTEXBUMPPARAMETERFVATIPROC_HPP>(_impl::_get_proc_address("glTexBumpParameterfvATI","GL_ATI_envmap_bumpmap"));
	 fn(pname,param);
}

typedef void (*PFNGETTEXBUMPPARAMETERIVATIPROC_HPP)(GLenum pname,GLint *param);

static inline void GetTexBumpParameterivATI(GLenum pname,GLint *param)
{
	static PFNGETTEXBUMPPARAMETERIVATIPROC_HPP fn=reinterpret_cast<PFNGETTEXBUMPPARAMETERIVATIPROC_HPP>(_impl::_get_proc_address("glGetTexBumpParameterivATI","GL_ATI_envmap_bumpmap"));
	 fn(pname,param);
}

typedef void (*PFNGETTEXBUMPPARAMETERFVATIPROC_HPP)(GLenum pname,GLfloat *param);

static inline void GetTexBumpParameterfvATI(GLenum pname,GLfloat *param)
{
	static PFNGETTEXBUMPPARAMETERFVATIPROC_HPP fn=reinterpret_cast<PFNGETTEXBUMPPARAMETERFVATIPROC_HPP>(_impl::_get_proc_address("glGetTexBumpParameterfvATI","GL_ATI_envmap_bumpmap"));
	 fn(pname,param);
}
#ifndef GL_ATI_fragment_shader

#define GL_ATI_fragment_shader
#ifndef GL_RED_BIT_ATI
#define GL_RED_BIT_ATI                                                  0x00000001
#endif //GL_RED_BIT_ATI
#ifndef GL_2X_BIT_ATI
#define GL_2X_BIT_ATI                                                   0x00000001
#endif //GL_2X_BIT_ATI
#ifndef GL_4X_BIT_ATI
#define GL_4X_BIT_ATI                                                   0x00000002
#endif //GL_4X_BIT_ATI
#ifndef GL_COMP_BIT_ATI
#define GL_COMP_BIT_ATI                                                 0x00000002
#endif //GL_COMP_BIT_ATI
#ifndef GL_GREEN_BIT_ATI
#define GL_GREEN_BIT_ATI                                                0x00000002
#endif //GL_GREEN_BIT_ATI
#ifndef GL_8X_BIT_ATI
#define GL_8X_BIT_ATI                                                   0x00000004
#endif //GL_8X_BIT_ATI
#ifndef GL_BLUE_BIT_ATI
#define GL_BLUE_BIT_ATI                                                 0x00000004
#endif //GL_BLUE_BIT_ATI
#ifndef GL_NEGATE_BIT_ATI
#define GL_NEGATE_BIT_ATI                                               0x00000004
#endif //GL_NEGATE_BIT_ATI
#ifndef GL_BIAS_BIT_ATI
#define GL_BIAS_BIT_ATI                                                 0x00000008
#endif //GL_BIAS_BIT_ATI
#ifndef GL_HALF_BIT_ATI
#define GL_HALF_BIT_ATI                                                 0x00000008
#endif //GL_HALF_BIT_ATI
#ifndef GL_QUARTER_BIT_ATI
#define GL_QUARTER_BIT_ATI                                              0x00000010
#endif //GL_QUARTER_BIT_ATI
#ifndef GL_EIGHTH_BIT_ATI
#define GL_EIGHTH_BIT_ATI                                               0x00000020
#endif //GL_EIGHTH_BIT_ATI
#ifndef GL_SATURATE_BIT_ATI
#define GL_SATURATE_BIT_ATI                                             0x00000040
#endif //GL_SATURATE_BIT_ATI
#ifndef GL_FRAGMENT_SHADER_ATI
#define GL_FRAGMENT_SHADER_ATI                                          0x8920
#endif //GL_FRAGMENT_SHADER_ATI
#ifndef GL_REG_0_ATI
#define GL_REG_0_ATI                                                    0x8921
#endif //GL_REG_0_ATI
#ifndef GL_REG_1_ATI
#define GL_REG_1_ATI                                                    0x8922
#endif //GL_REG_1_ATI
#ifndef GL_REG_2_ATI
#define GL_REG_2_ATI                                                    0x8923
#endif //GL_REG_2_ATI
#ifndef GL_REG_3_ATI
#define GL_REG_3_ATI                                                    0x8924
#endif //GL_REG_3_ATI
#ifndef GL_REG_4_ATI
#define GL_REG_4_ATI                                                    0x8925
#endif //GL_REG_4_ATI
#ifndef GL_REG_5_ATI
#define GL_REG_5_ATI                                                    0x8926
#endif //GL_REG_5_ATI
#ifndef GL_REG_6_ATI
#define GL_REG_6_ATI                                                    0x8927
#endif //GL_REG_6_ATI
#ifndef GL_REG_7_ATI
#define GL_REG_7_ATI                                                    0x8928
#endif //GL_REG_7_ATI
#ifndef GL_REG_8_ATI
#define GL_REG_8_ATI                                                    0x8929
#endif //GL_REG_8_ATI
#ifndef GL_REG_9_ATI
#define GL_REG_9_ATI                                                    0x892A
#endif //GL_REG_9_ATI
#ifndef GL_REG_10_ATI
#define GL_REG_10_ATI                                                   0x892B
#endif //GL_REG_10_ATI
#ifndef GL_REG_11_ATI
#define GL_REG_11_ATI                                                   0x892C
#endif //GL_REG_11_ATI
#ifndef GL_REG_12_ATI
#define GL_REG_12_ATI                                                   0x892D
#endif //GL_REG_12_ATI
#ifndef GL_REG_13_ATI
#define GL_REG_13_ATI                                                   0x892E
#endif //GL_REG_13_ATI
#ifndef GL_REG_14_ATI
#define GL_REG_14_ATI                                                   0x892F
#endif //GL_REG_14_ATI
#ifndef GL_REG_15_ATI
#define GL_REG_15_ATI                                                   0x8930
#endif //GL_REG_15_ATI
#ifndef GL_REG_16_ATI
#define GL_REG_16_ATI                                                   0x8931
#endif //GL_REG_16_ATI
#ifndef GL_REG_17_ATI
#define GL_REG_17_ATI                                                   0x8932
#endif //GL_REG_17_ATI
#ifndef GL_REG_18_ATI
#define GL_REG_18_ATI                                                   0x8933
#endif //GL_REG_18_ATI
#ifndef GL_REG_19_ATI
#define GL_REG_19_ATI                                                   0x8934
#endif //GL_REG_19_ATI
#ifndef GL_REG_20_ATI
#define GL_REG_20_ATI                                                   0x8935
#endif //GL_REG_20_ATI
#ifndef GL_REG_21_ATI
#define GL_REG_21_ATI                                                   0x8936
#endif //GL_REG_21_ATI
#ifndef GL_REG_22_ATI
#define GL_REG_22_ATI                                                   0x8937
#endif //GL_REG_22_ATI
#ifndef GL_REG_23_ATI
#define GL_REG_23_ATI                                                   0x8938
#endif //GL_REG_23_ATI
#ifndef GL_REG_24_ATI
#define GL_REG_24_ATI                                                   0x8939
#endif //GL_REG_24_ATI
#ifndef GL_REG_25_ATI
#define GL_REG_25_ATI                                                   0x893A
#endif //GL_REG_25_ATI
#ifndef GL_REG_26_ATI
#define GL_REG_26_ATI                                                   0x893B
#endif //GL_REG_26_ATI
#ifndef GL_REG_27_ATI
#define GL_REG_27_ATI                                                   0x893C
#endif //GL_REG_27_ATI
#ifndef GL_REG_28_ATI
#define GL_REG_28_ATI                                                   0x893D
#endif //GL_REG_28_ATI
#ifndef GL_REG_29_ATI
#define GL_REG_29_ATI                                                   0x893E
#endif //GL_REG_29_ATI
#ifndef GL_REG_30_ATI
#define GL_REG_30_ATI                                                   0x893F
#endif //GL_REG_30_ATI
#ifndef GL_REG_31_ATI
#define GL_REG_31_ATI                                                   0x8940
#endif //GL_REG_31_ATI
#ifndef GL_CON_0_ATI
#define GL_CON_0_ATI                                                    0x8941
#endif //GL_CON_0_ATI
#ifndef GL_CON_1_ATI
#define GL_CON_1_ATI                                                    0x8942
#endif //GL_CON_1_ATI
#ifndef GL_CON_2_ATI
#define GL_CON_2_ATI                                                    0x8943
#endif //GL_CON_2_ATI
#ifndef GL_CON_3_ATI
#define GL_CON_3_ATI                                                    0x8944
#endif //GL_CON_3_ATI
#ifndef GL_CON_4_ATI
#define GL_CON_4_ATI                                                    0x8945
#endif //GL_CON_4_ATI
#ifndef GL_CON_5_ATI
#define GL_CON_5_ATI                                                    0x8946
#endif //GL_CON_5_ATI
#ifndef GL_CON_6_ATI
#define GL_CON_6_ATI                                                    0x8947
#endif //GL_CON_6_ATI
#ifndef GL_CON_7_ATI
#define GL_CON_7_ATI                                                    0x8948
#endif //GL_CON_7_ATI
#ifndef GL_CON_8_ATI
#define GL_CON_8_ATI                                                    0x8949
#endif //GL_CON_8_ATI
#ifndef GL_CON_9_ATI
#define GL_CON_9_ATI                                                    0x894A
#endif //GL_CON_9_ATI
#ifndef GL_CON_10_ATI
#define GL_CON_10_ATI                                                   0x894B
#endif //GL_CON_10_ATI
#ifndef GL_CON_11_ATI
#define GL_CON_11_ATI                                                   0x894C
#endif //GL_CON_11_ATI
#ifndef GL_CON_12_ATI
#define GL_CON_12_ATI                                                   0x894D
#endif //GL_CON_12_ATI
#ifndef GL_CON_13_ATI
#define GL_CON_13_ATI                                                   0x894E
#endif //GL_CON_13_ATI
#ifndef GL_CON_14_ATI
#define GL_CON_14_ATI                                                   0x894F
#endif //GL_CON_14_ATI
#ifndef GL_CON_15_ATI
#define GL_CON_15_ATI                                                   0x8950
#endif //GL_CON_15_ATI
#ifndef GL_CON_16_ATI
#define GL_CON_16_ATI                                                   0x8951
#endif //GL_CON_16_ATI
#ifndef GL_CON_17_ATI
#define GL_CON_17_ATI                                                   0x8952
#endif //GL_CON_17_ATI
#ifndef GL_CON_18_ATI
#define GL_CON_18_ATI                                                   0x8953
#endif //GL_CON_18_ATI
#ifndef GL_CON_19_ATI
#define GL_CON_19_ATI                                                   0x8954
#endif //GL_CON_19_ATI
#ifndef GL_CON_20_ATI
#define GL_CON_20_ATI                                                   0x8955
#endif //GL_CON_20_ATI
#ifndef GL_CON_21_ATI
#define GL_CON_21_ATI                                                   0x8956
#endif //GL_CON_21_ATI
#ifndef GL_CON_22_ATI
#define GL_CON_22_ATI                                                   0x8957
#endif //GL_CON_22_ATI
#ifndef GL_CON_23_ATI
#define GL_CON_23_ATI                                                   0x8958
#endif //GL_CON_23_ATI
#ifndef GL_CON_24_ATI
#define GL_CON_24_ATI                                                   0x8959
#endif //GL_CON_24_ATI
#ifndef GL_CON_25_ATI
#define GL_CON_25_ATI                                                   0x895A
#endif //GL_CON_25_ATI
#ifndef GL_CON_26_ATI
#define GL_CON_26_ATI                                                   0x895B
#endif //GL_CON_26_ATI
#ifndef GL_CON_27_ATI
#define GL_CON_27_ATI                                                   0x895C
#endif //GL_CON_27_ATI
#ifndef GL_CON_28_ATI
#define GL_CON_28_ATI                                                   0x895D
#endif //GL_CON_28_ATI
#ifndef GL_CON_29_ATI
#define GL_CON_29_ATI                                                   0x895E
#endif //GL_CON_29_ATI
#ifndef GL_CON_30_ATI
#define GL_CON_30_ATI                                                   0x895F
#endif //GL_CON_30_ATI
#ifndef GL_CON_31_ATI
#define GL_CON_31_ATI                                                   0x8960
#endif //GL_CON_31_ATI
#ifndef GL_MOV_ATI
#define GL_MOV_ATI                                                      0x8961
#endif //GL_MOV_ATI
#ifndef GL_ADD_ATI
#define GL_ADD_ATI                                                      0x8963
#endif //GL_ADD_ATI
#ifndef GL_MUL_ATI
#define GL_MUL_ATI                                                      0x8964
#endif //GL_MUL_ATI
#ifndef GL_SUB_ATI
#define GL_SUB_ATI                                                      0x8965
#endif //GL_SUB_ATI
#ifndef GL_DOT3_ATI
#define GL_DOT3_ATI                                                     0x8966
#endif //GL_DOT3_ATI
#ifndef GL_DOT4_ATI
#define GL_DOT4_ATI                                                     0x8967
#endif //GL_DOT4_ATI
#ifndef GL_MAD_ATI
#define GL_MAD_ATI                                                      0x8968
#endif //GL_MAD_ATI
#ifndef GL_LERP_ATI
#define GL_LERP_ATI                                                     0x8969
#endif //GL_LERP_ATI
#ifndef GL_CND_ATI
#define GL_CND_ATI                                                      0x896A
#endif //GL_CND_ATI
#ifndef GL_CND0_ATI
#define GL_CND0_ATI                                                     0x896B
#endif //GL_CND0_ATI
#ifndef GL_DOT2_ADD_ATI
#define GL_DOT2_ADD_ATI                                                 0x896C
#endif //GL_DOT2_ADD_ATI
#ifndef GL_SECONDARY_INTERPOLATOR_ATI
#define GL_SECONDARY_INTERPOLATOR_ATI                                   0x896D
#endif //GL_SECONDARY_INTERPOLATOR_ATI
#ifndef GL_NUM_FRAGMENT_REGISTERS_ATI
#define GL_NUM_FRAGMENT_REGISTERS_ATI                                   0x896E
#endif //GL_NUM_FRAGMENT_REGISTERS_ATI
#ifndef GL_NUM_FRAGMENT_CONSTANTS_ATI
#define GL_NUM_FRAGMENT_CONSTANTS_ATI                                   0x896F
#endif //GL_NUM_FRAGMENT_CONSTANTS_ATI
#ifndef GL_NUM_PASSES_ATI
#define GL_NUM_PASSES_ATI                                               0x8970
#endif //GL_NUM_PASSES_ATI
#ifndef GL_NUM_INSTRUCTIONS_PER_PASS_ATI
#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI                                0x8971
#endif //GL_NUM_INSTRUCTIONS_PER_PASS_ATI
#ifndef GL_NUM_INSTRUCTIONS_TOTAL_ATI
#define GL_NUM_INSTRUCTIONS_TOTAL_ATI                                   0x8972
#endif //GL_NUM_INSTRUCTIONS_TOTAL_ATI
#ifndef GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI
#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI                        0x8973
#endif //GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI
#ifndef GL_NUM_LOOPBACK_COMPONENTS_ATI
#define GL_NUM_LOOPBACK_COMPONENTS_ATI                                  0x8974
#endif //GL_NUM_LOOPBACK_COMPONENTS_ATI
#ifndef GL_COLOR_ALPHA_PAIRING_ATI
#define GL_COLOR_ALPHA_PAIRING_ATI                                      0x8975
#endif //GL_COLOR_ALPHA_PAIRING_ATI
#ifndef GL_SWIZZLE_STR_ATI
#define GL_SWIZZLE_STR_ATI                                              0x8976
#endif //GL_SWIZZLE_STR_ATI
#ifndef GL_SWIZZLE_STQ_ATI
#define GL_SWIZZLE_STQ_ATI                                              0x8977
#endif //GL_SWIZZLE_STQ_ATI
#ifndef GL_SWIZZLE_STR_DR_ATI
#define GL_SWIZZLE_STR_DR_ATI                                           0x8978
#endif //GL_SWIZZLE_STR_DR_ATI
#ifndef GL_SWIZZLE_STQ_DQ_ATI
#define GL_SWIZZLE_STQ_DQ_ATI                                           0x8979
#endif //GL_SWIZZLE_STQ_DQ_ATI
#ifndef GL_SWIZZLE_STRQ_ATI
#define GL_SWIZZLE_STRQ_ATI                                             0x897A
#endif //GL_SWIZZLE_STRQ_ATI
#ifndef GL_SWIZZLE_STRQ_DQ_ATI
#define GL_SWIZZLE_STRQ_DQ_ATI                                          0x897B
#endif //GL_SWIZZLE_STRQ_DQ_ATI

#endif //GL_ATI_fragment_shader


typedef GLuint (*PFNGENFRAGMENTSHADERSATIPROC_HPP)(GLuint range);

static inline GLuint GenFragmentShadersATI(GLuint range)
{
	static PFNGENFRAGMENTSHADERSATIPROC_HPP fn=reinterpret_cast<PFNGENFRAGMENTSHADERSATIPROC_HPP>(_impl::_get_proc_address("glGenFragmentShadersATI","GL_ATI_fragment_shader"));
	return fn(range);
}

typedef void (*PFNBINDFRAGMENTSHADERATIPROC_HPP)(GLuint id);

static inline void BindFragmentShaderATI(GLuint id)
{
	static PFNBINDFRAGMENTSHADERATIPROC_HPP fn=reinterpret_cast<PFNBINDFRAGMENTSHADERATIPROC_HPP>(_impl::_get_proc_address("glBindFragmentShaderATI","GL_ATI_fragment_shader"));
	 fn(id);
}

typedef void (*PFNDELETEFRAGMENTSHADERATIPROC_HPP)(GLuint id);

static inline void DeleteFragmentShaderATI(GLuint id)
{
	static PFNDELETEFRAGMENTSHADERATIPROC_HPP fn=reinterpret_cast<PFNDELETEFRAGMENTSHADERATIPROC_HPP>(_impl::_get_proc_address("glDeleteFragmentShaderATI","GL_ATI_fragment_shader"));
	 fn(id);
}

typedef void (*PFNBEGINFRAGMENTSHADERATIPROC_HPP)();

static inline void BeginFragmentShaderATI()
{
	static PFNBEGINFRAGMENTSHADERATIPROC_HPP fn=reinterpret_cast<PFNBEGINFRAGMENTSHADERATIPROC_HPP>(_impl::_get_proc_address("glBeginFragmentShaderATI","GL_ATI_fragment_shader"));
	 fn();
}

typedef void (*PFNENDFRAGMENTSHADERATIPROC_HPP)();

static inline void EndFragmentShaderATI()
{
	static PFNENDFRAGMENTSHADERATIPROC_HPP fn=reinterpret_cast<PFNENDFRAGMENTSHADERATIPROC_HPP>(_impl::_get_proc_address("glEndFragmentShaderATI","GL_ATI_fragment_shader"));
	 fn();
}

typedef void (*PFNPASSTEXCOORDATIPROC_HPP)(GLuint dst,GLuint coord,GLenum swizzle);

static inline void PassTexCoordATI(GLuint dst,GLuint coord,GLenum swizzle)
{
	static PFNPASSTEXCOORDATIPROC_HPP fn=reinterpret_cast<PFNPASSTEXCOORDATIPROC_HPP>(_impl::_get_proc_address("glPassTexCoordATI","GL_ATI_fragment_shader"));
	 fn(dst,coord,swizzle);
}

typedef void (*PFNSAMPLEMAPATIPROC_HPP)(GLuint dst,GLuint interp,GLenum swizzle);

static inline void SampleMapATI(GLuint dst,GLuint interp,GLenum swizzle)
{
	static PFNSAMPLEMAPATIPROC_HPP fn=reinterpret_cast<PFNSAMPLEMAPATIPROC_HPP>(_impl::_get_proc_address("glSampleMapATI","GL_ATI_fragment_shader"));
	 fn(dst,interp,swizzle);
}

typedef void (*PFNCOLORFRAGMENTOP1ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod);

static inline void ColorFragmentOp1ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod)
{
	static PFNCOLORFRAGMENTOP1ATIPROC_HPP fn=reinterpret_cast<PFNCOLORFRAGMENTOP1ATIPROC_HPP>(_impl::_get_proc_address("glColorFragmentOp1ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod);
}

typedef void (*PFNCOLORFRAGMENTOP2ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod);

static inline void ColorFragmentOp2ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod)
{
	static PFNCOLORFRAGMENTOP2ATIPROC_HPP fn=reinterpret_cast<PFNCOLORFRAGMENTOP2ATIPROC_HPP>(_impl::_get_proc_address("glColorFragmentOp2ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod);
}

typedef void (*PFNCOLORFRAGMENTOP3ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod);

static inline void ColorFragmentOp3ATI(GLenum op,GLuint dst,GLuint dstMask,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod)
{
	static PFNCOLORFRAGMENTOP3ATIPROC_HPP fn=reinterpret_cast<PFNCOLORFRAGMENTOP3ATIPROC_HPP>(_impl::_get_proc_address("glColorFragmentOp3ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod,arg3,arg3Rep,arg3Mod);
}

typedef void (*PFNALPHAFRAGMENTOP1ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod);

static inline void AlphaFragmentOp1ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod)
{
	static PFNALPHAFRAGMENTOP1ATIPROC_HPP fn=reinterpret_cast<PFNALPHAFRAGMENTOP1ATIPROC_HPP>(_impl::_get_proc_address("glAlphaFragmentOp1ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMod,arg1,arg1Rep,arg1Mod);
}

typedef void (*PFNALPHAFRAGMENTOP2ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod);

static inline void AlphaFragmentOp2ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod)
{
	static PFNALPHAFRAGMENTOP2ATIPROC_HPP fn=reinterpret_cast<PFNALPHAFRAGMENTOP2ATIPROC_HPP>(_impl::_get_proc_address("glAlphaFragmentOp2ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod);
}

typedef void (*PFNALPHAFRAGMENTOP3ATIPROC_HPP)(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod);

static inline void AlphaFragmentOp3ATI(GLenum op,GLuint dst,GLuint dstMod,GLuint arg1,GLuint arg1Rep,GLuint arg1Mod,GLuint arg2,GLuint arg2Rep,GLuint arg2Mod,GLuint arg3,GLuint arg3Rep,GLuint arg3Mod)
{
	static PFNALPHAFRAGMENTOP3ATIPROC_HPP fn=reinterpret_cast<PFNALPHAFRAGMENTOP3ATIPROC_HPP>(_impl::_get_proc_address("glAlphaFragmentOp3ATI","GL_ATI_fragment_shader"));
	 fn(op,dst,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod,arg3,arg3Rep,arg3Mod);
}

typedef void (*PFNSETFRAGMENTSHADERCONSTANTATIPROC_HPP)(GLuint dst,const GLfloat *value);

static inline void SetFragmentShaderConstantATI(GLuint dst,const GLfloat *value)
{
	static PFNSETFRAGMENTSHADERCONSTANTATIPROC_HPP fn=reinterpret_cast<PFNSETFRAGMENTSHADERCONSTANTATIPROC_HPP>(_impl::_get_proc_address("glSetFragmentShaderConstantATI","GL_ATI_fragment_shader"));
	 fn(dst,value);
}
#ifndef GL_ATI_map_object_buffer

#define GL_ATI_map_object_buffer

#endif //GL_ATI_map_object_buffer


typedef GLvoid* (*PFNMAPOBJECTBUFFERATIPROC_HPP)(GLuint buffer);

static inline GLvoid* MapObjectBufferATI(GLuint buffer)
{
	static PFNMAPOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNMAPOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glMapObjectBufferATI","GL_ATI_map_object_buffer"));
	return fn(buffer);
}

typedef void (*PFNUNMAPOBJECTBUFFERATIPROC_HPP)(GLuint buffer);

static inline void UnmapObjectBufferATI(GLuint buffer)
{
	static PFNUNMAPOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNUNMAPOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glUnmapObjectBufferATI","GL_ATI_map_object_buffer"));
	 fn(buffer);
}
#ifndef GL_ATI_meminfo

#define GL_ATI_meminfo
#ifndef GL_VBO_FREE_MEMORY_ATI
#define GL_VBO_FREE_MEMORY_ATI                                          0x87FB
#endif //GL_VBO_FREE_MEMORY_ATI
#ifndef GL_TEXTURE_FREE_MEMORY_ATI
#define GL_TEXTURE_FREE_MEMORY_ATI                                      0x87FC
#endif //GL_TEXTURE_FREE_MEMORY_ATI
#ifndef GL_RENDERBUFFER_FREE_MEMORY_ATI
#define GL_RENDERBUFFER_FREE_MEMORY_ATI                                 0x87FD
#endif //GL_RENDERBUFFER_FREE_MEMORY_ATI

#endif //GL_ATI_meminfo

#ifndef GL_ATI_pixel_format_float

#define GL_ATI_pixel_format_float
#ifndef GL_TYPE_RGBA_FLOAT_ATI
#define GL_TYPE_RGBA_FLOAT_ATI                                          0x8820
#endif //GL_TYPE_RGBA_FLOAT_ATI
#ifndef GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI
#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI                              0x8835
#endif //GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI

#endif //GL_ATI_pixel_format_float

#ifndef GL_ATI_pn_triangles

#define GL_ATI_pn_triangles
#ifndef GL_PN_TRIANGLES_ATI
#define GL_PN_TRIANGLES_ATI                                             0x87F0
#endif //GL_PN_TRIANGLES_ATI
#ifndef GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI
#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI                       0x87F1
#endif //GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI
#ifndef GL_PN_TRIANGLES_POINT_MODE_ATI
#define GL_PN_TRIANGLES_POINT_MODE_ATI                                  0x87F2
#endif //GL_PN_TRIANGLES_POINT_MODE_ATI
#ifndef GL_PN_TRIANGLES_NORMAL_MODE_ATI
#define GL_PN_TRIANGLES_NORMAL_MODE_ATI                                 0x87F3
#endif //GL_PN_TRIANGLES_NORMAL_MODE_ATI
#ifndef GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI
#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI                           0x87F4
#endif //GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI
#ifndef GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI
#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI                           0x87F5
#endif //GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI
#ifndef GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI
#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI                            0x87F6
#endif //GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI
#ifndef GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI
#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI                          0x87F7
#endif //GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI
#ifndef GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI
#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI                       0x87F8
#endif //GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI

#endif //GL_ATI_pn_triangles


typedef void (*PFNPNTRIANGLESIATIPROC_HPP)(GLenum pname,GLint param);

static inline void PNTrianglesiATI(GLenum pname,GLint param)
{
	static PFNPNTRIANGLESIATIPROC_HPP fn=reinterpret_cast<PFNPNTRIANGLESIATIPROC_HPP>(_impl::_get_proc_address("glPNTrianglesiATI","GL_ATI_pn_triangles"));
	 fn(pname,param);
}

typedef void (*PFNPNTRIANGLESFATIPROC_HPP)(GLenum pname,GLfloat param);

static inline void PNTrianglesfATI(GLenum pname,GLfloat param)
{
	static PFNPNTRIANGLESFATIPROC_HPP fn=reinterpret_cast<PFNPNTRIANGLESFATIPROC_HPP>(_impl::_get_proc_address("glPNTrianglesfATI","GL_ATI_pn_triangles"));
	 fn(pname,param);
}
#ifndef GL_ATI_separate_stencil

#define GL_ATI_separate_stencil
#ifndef GL_STENCIL_BACK_FUNC_ATI
#define GL_STENCIL_BACK_FUNC_ATI                                        0x8800
#endif //GL_STENCIL_BACK_FUNC_ATI
#ifndef GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI
#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI                             0x8802
#endif //GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI
#ifndef GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI
#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI                             0x8803
#endif //GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI

#endif //GL_ATI_separate_stencil


typedef void (*PFNSTENCILOPSEPARATEATIPROC_HPP)(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass);

static inline void StencilOpSeparateATI(GLenum face,GLenum sfail,GLenum dpfail,GLenum dppass)
{
	static PFNSTENCILOPSEPARATEATIPROC_HPP fn=reinterpret_cast<PFNSTENCILOPSEPARATEATIPROC_HPP>(_impl::_get_proc_address("glStencilOpSeparateATI","GL_ATI_separate_stencil"));
	 fn(face,sfail,dpfail,dppass);
}

typedef void (*PFNSTENCILFUNCSEPARATEATIPROC_HPP)(GLenum frontfunc,GLenum backfunc,GLint ref,GLuint mask);

static inline void StencilFuncSeparateATI(GLenum frontfunc,GLenum backfunc,GLint ref,GLuint mask)
{
	static PFNSTENCILFUNCSEPARATEATIPROC_HPP fn=reinterpret_cast<PFNSTENCILFUNCSEPARATEATIPROC_HPP>(_impl::_get_proc_address("glStencilFuncSeparateATI","GL_ATI_separate_stencil"));
	 fn(frontfunc,backfunc,ref,mask);
}
#ifndef GL_ATI_text_fragment_shader

#define GL_ATI_text_fragment_shader
#ifndef GL_TEXT_FRAGMENT_SHADER_ATI
#define GL_TEXT_FRAGMENT_SHADER_ATI                                     0x8200
#endif //GL_TEXT_FRAGMENT_SHADER_ATI

#endif //GL_ATI_text_fragment_shader

#ifndef GL_ATI_texture_env_combine3

#define GL_ATI_texture_env_combine3
#ifndef GL_MODULATE_ADD_ATI
#define GL_MODULATE_ADD_ATI                                             0x8744
#endif //GL_MODULATE_ADD_ATI
#ifndef GL_MODULATE_SIGNED_ADD_ATI
#define GL_MODULATE_SIGNED_ADD_ATI                                      0x8745
#endif //GL_MODULATE_SIGNED_ADD_ATI
#ifndef GL_MODULATE_SUBTRACT_ATI
#define GL_MODULATE_SUBTRACT_ATI                                        0x8746
#endif //GL_MODULATE_SUBTRACT_ATI

#endif //GL_ATI_texture_env_combine3

#ifndef GL_ATI_texture_float

#define GL_ATI_texture_float
#ifndef GL_RGBA_FLOAT32_ATI
#define GL_RGBA_FLOAT32_ATI                                             0x8814
#endif //GL_RGBA_FLOAT32_ATI
#ifndef GL_RGB_FLOAT32_ATI
#define GL_RGB_FLOAT32_ATI                                              0x8815
#endif //GL_RGB_FLOAT32_ATI
#ifndef GL_ALPHA_FLOAT32_ATI
#define GL_ALPHA_FLOAT32_ATI                                            0x8816
#endif //GL_ALPHA_FLOAT32_ATI
#ifndef GL_INTENSITY_FLOAT32_ATI
#define GL_INTENSITY_FLOAT32_ATI                                        0x8817
#endif //GL_INTENSITY_FLOAT32_ATI
#ifndef GL_LUMINANCE_FLOAT32_ATI
#define GL_LUMINANCE_FLOAT32_ATI                                        0x8818
#endif //GL_LUMINANCE_FLOAT32_ATI
#ifndef GL_LUMINANCE_ALPHA_FLOAT32_ATI
#define GL_LUMINANCE_ALPHA_FLOAT32_ATI                                  0x8819
#endif //GL_LUMINANCE_ALPHA_FLOAT32_ATI
#ifndef GL_RGBA_FLOAT16_ATI
#define GL_RGBA_FLOAT16_ATI                                             0x881A
#endif //GL_RGBA_FLOAT16_ATI
#ifndef GL_RGB_FLOAT16_ATI
#define GL_RGB_FLOAT16_ATI                                              0x881B
#endif //GL_RGB_FLOAT16_ATI
#ifndef GL_ALPHA_FLOAT16_ATI
#define GL_ALPHA_FLOAT16_ATI                                            0x881C
#endif //GL_ALPHA_FLOAT16_ATI
#ifndef GL_INTENSITY_FLOAT16_ATI
#define GL_INTENSITY_FLOAT16_ATI                                        0x881D
#endif //GL_INTENSITY_FLOAT16_ATI
#ifndef GL_LUMINANCE_FLOAT16_ATI
#define GL_LUMINANCE_FLOAT16_ATI                                        0x881E
#endif //GL_LUMINANCE_FLOAT16_ATI
#ifndef GL_LUMINANCE_ALPHA_FLOAT16_ATI
#define GL_LUMINANCE_ALPHA_FLOAT16_ATI                                  0x881F
#endif //GL_LUMINANCE_ALPHA_FLOAT16_ATI

#endif //GL_ATI_texture_float

#ifndef GL_ATI_texture_mirror_once

#define GL_ATI_texture_mirror_once
#ifndef GL_MIRROR_CLAMP_ATI
#define GL_MIRROR_CLAMP_ATI                                             0x8742
#endif //GL_MIRROR_CLAMP_ATI
#ifndef GL_MIRROR_CLAMP_TO_EDGE_ATI
#define GL_MIRROR_CLAMP_TO_EDGE_ATI                                     0x8743
#endif //GL_MIRROR_CLAMP_TO_EDGE_ATI

#endif //GL_ATI_texture_mirror_once

#ifndef GL_ATI_vertex_array_object

#define GL_ATI_vertex_array_object
#ifndef GL_STATIC_ATI
#define GL_STATIC_ATI                                                   0x8760
#endif //GL_STATIC_ATI
#ifndef GL_DYNAMIC_ATI
#define GL_DYNAMIC_ATI                                                  0x8761
#endif //GL_DYNAMIC_ATI
#ifndef GL_PRESERVE_ATI
#define GL_PRESERVE_ATI                                                 0x8762
#endif //GL_PRESERVE_ATI
#ifndef GL_DISCARD_ATI
#define GL_DISCARD_ATI                                                  0x8763
#endif //GL_DISCARD_ATI
#ifndef GL_OBJECT_BUFFER_SIZE_ATI
#define GL_OBJECT_BUFFER_SIZE_ATI                                       0x8764
#endif //GL_OBJECT_BUFFER_SIZE_ATI
#ifndef GL_OBJECT_BUFFER_USAGE_ATI
#define GL_OBJECT_BUFFER_USAGE_ATI                                      0x8765
#endif //GL_OBJECT_BUFFER_USAGE_ATI
#ifndef GL_ARRAY_OBJECT_BUFFER_ATI
#define GL_ARRAY_OBJECT_BUFFER_ATI                                      0x8766
#endif //GL_ARRAY_OBJECT_BUFFER_ATI
#ifndef GL_ARRAY_OBJECT_OFFSET_ATI
#define GL_ARRAY_OBJECT_OFFSET_ATI                                      0x8767
#endif //GL_ARRAY_OBJECT_OFFSET_ATI

#endif //GL_ATI_vertex_array_object


typedef GLuint (*PFNNEWOBJECTBUFFERATIPROC_HPP)(GLsizei size,const GLvoid *pointer,GLenum usage);

static inline GLuint NewObjectBufferATI(GLsizei size,const GLvoid *pointer,GLenum usage)
{
	static PFNNEWOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNNEWOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glNewObjectBufferATI","GL_ATI_vertex_array_object"));
	return fn(size,pointer,usage);
}

typedef GLboolean (*PFNISOBJECTBUFFERATIPROC_HPP)(GLuint buffer);

static inline GLboolean IsObjectBufferATI(GLuint buffer)
{
	static PFNISOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNISOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glIsObjectBufferATI","GL_ATI_vertex_array_object"));
	return fn(buffer);
}

typedef void (*PFNUPDATEOBJECTBUFFERATIPROC_HPP)(GLuint buffer,GLuint offset,GLsizei size,const GLvoid *pointer,GLenum preserve);

static inline void UpdateObjectBufferATI(GLuint buffer,GLuint offset,GLsizei size,const GLvoid *pointer,GLenum preserve)
{
	static PFNUPDATEOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNUPDATEOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glUpdateObjectBufferATI","GL_ATI_vertex_array_object"));
	 fn(buffer,offset,size,pointer,preserve);
}

typedef void (*PFNGETOBJECTBUFFERFVATIPROC_HPP)(GLuint buffer,GLenum pname,GLfloat *params);

static inline void GetObjectBufferfvATI(GLuint buffer,GLenum pname,GLfloat *params)
{
	static PFNGETOBJECTBUFFERFVATIPROC_HPP fn=reinterpret_cast<PFNGETOBJECTBUFFERFVATIPROC_HPP>(_impl::_get_proc_address("glGetObjectBufferfvATI","GL_ATI_vertex_array_object"));
	 fn(buffer,pname,params);
}

typedef void (*PFNGETOBJECTBUFFERIVATIPROC_HPP)(GLuint buffer,GLenum pname,GLint *params);

static inline void GetObjectBufferivATI(GLuint buffer,GLenum pname,GLint *params)
{
	static PFNGETOBJECTBUFFERIVATIPROC_HPP fn=reinterpret_cast<PFNGETOBJECTBUFFERIVATIPROC_HPP>(_impl::_get_proc_address("glGetObjectBufferivATI","GL_ATI_vertex_array_object"));
	 fn(buffer,pname,params);
}

typedef void (*PFNFREEOBJECTBUFFERATIPROC_HPP)(GLuint buffer);

static inline void FreeObjectBufferATI(GLuint buffer)
{
	static PFNFREEOBJECTBUFFERATIPROC_HPP fn=reinterpret_cast<PFNFREEOBJECTBUFFERATIPROC_HPP>(_impl::_get_proc_address("glFreeObjectBufferATI","GL_ATI_vertex_array_object"));
	 fn(buffer);
}

typedef void (*PFNARRAYOBJECTATIPROC_HPP)(GLenum array,GLint size,GLenum type,GLsizei stride,GLuint buffer,GLuint offset);

static inline void ArrayObjectATI(GLenum array,GLint size,GLenum type,GLsizei stride,GLuint buffer,GLuint offset)
{
	static PFNARRAYOBJECTATIPROC_HPP fn=reinterpret_cast<PFNARRAYOBJECTATIPROC_HPP>(_impl::_get_proc_address("glArrayObjectATI","GL_ATI_vertex_array_object"));
	 fn(array,size,type,stride,buffer,offset);
}

typedef void (*PFNGETARRAYOBJECTFVATIPROC_HPP)(GLenum array,GLenum pname,GLfloat *params);

static inline void GetArrayObjectfvATI(GLenum array,GLenum pname,GLfloat *params)
{
	static PFNGETARRAYOBJECTFVATIPROC_HPP fn=reinterpret_cast<PFNGETARRAYOBJECTFVATIPROC_HPP>(_impl::_get_proc_address("glGetArrayObjectfvATI","GL_ATI_vertex_array_object"));
	 fn(array,pname,params);
}

typedef void (*PFNGETARRAYOBJECTIVATIPROC_HPP)(GLenum array,GLenum pname,GLint *params);

static inline void GetArrayObjectivATI(GLenum array,GLenum pname,GLint *params)
{
	static PFNGETARRAYOBJECTIVATIPROC_HPP fn=reinterpret_cast<PFNGETARRAYOBJECTIVATIPROC_HPP>(_impl::_get_proc_address("glGetArrayObjectivATI","GL_ATI_vertex_array_object"));
	 fn(array,pname,params);
}

typedef void (*PFNVARIANTARRAYOBJECTATIPROC_HPP)(GLuint id,GLenum type,GLsizei stride,GLuint buffer,GLuint offset);

static inline void VariantArrayObjectATI(GLuint id,GLenum type,GLsizei stride,GLuint buffer,GLuint offset)
{
	static PFNVARIANTARRAYOBJECTATIPROC_HPP fn=reinterpret_cast<PFNVARIANTARRAYOBJECTATIPROC_HPP>(_impl::_get_proc_address("glVariantArrayObjectATI","GL_ATI_vertex_array_object"));
	 fn(id,type,stride,buffer,offset);
}

typedef void (*PFNGETVARIANTARRAYOBJECTFVATIPROC_HPP)(GLuint id,GLenum pname,GLfloat *params);

static inline void GetVariantArrayObjectfvATI(GLuint id,GLenum pname,GLfloat *params)
{
	static PFNGETVARIANTARRAYOBJECTFVATIPROC_HPP fn=reinterpret_cast<PFNGETVARIANTARRAYOBJECTFVATIPROC_HPP>(_impl::_get_proc_address("glGetVariantArrayObjectfvATI","GL_ATI_vertex_array_object"));
	 fn(id,pname,params);
}

typedef void (*PFNGETVARIANTARRAYOBJECTIVATIPROC_HPP)(GLuint id,GLenum pname,GLint *params);

static inline void GetVariantArrayObjectivATI(GLuint id,GLenum pname,GLint *params)
{
	static PFNGETVARIANTARRAYOBJECTIVATIPROC_HPP fn=reinterpret_cast<PFNGETVARIANTARRAYOBJECTIVATIPROC_HPP>(_impl::_get_proc_address("glGetVariantArrayObjectivATI","GL_ATI_vertex_array_object"));
	 fn(id,pname,params);
}
#ifndef GL_ATI_vertex_attrib_array_object

#define GL_ATI_vertex_attrib_array_object

#endif //GL_ATI_vertex_attrib_array_object


typedef void (*PFNVERTEXATTRIBARRAYOBJECTATIPROC_HPP)(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLuint buffer,GLuint offset);

static inline void VertexAttribArrayObjectATI(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLuint buffer,GLuint offset)
{
	static PFNVERTEXATTRIBARRAYOBJECTATIPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBARRAYOBJECTATIPROC_HPP>(_impl::_get_proc_address("glVertexAttribArrayObjectATI","GL_ATI_vertex_attrib_array_object"));
	 fn(index,size,type,normalized,stride,buffer,offset);
}

typedef void (*PFNGETVERTEXATTRIBARRAYOBJECTFVATIPROC_HPP)(GLuint index,GLenum pname,GLfloat *params);

static inline void GetVertexAttribArrayObjectfvATI(GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETVERTEXATTRIBARRAYOBJECTFVATIPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBARRAYOBJECTFVATIPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribArrayObjectfvATI","GL_ATI_vertex_attrib_array_object"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBARRAYOBJECTIVATIPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribArrayObjectivATI(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBARRAYOBJECTIVATIPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBARRAYOBJECTIVATIPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribArrayObjectivATI","GL_ATI_vertex_attrib_array_object"));
	 fn(index,pname,params);
}
#ifndef GL_ATI_vertex_streams

#define GL_ATI_vertex_streams
#ifndef GL_MAX_VERTEX_STREAMS_ATI
#define GL_MAX_VERTEX_STREAMS_ATI                                       0x876B
#endif //GL_MAX_VERTEX_STREAMS_ATI
#ifndef GL_VERTEX_STREAM0_ATI
#define GL_VERTEX_STREAM0_ATI                                           0x876C
#endif //GL_VERTEX_STREAM0_ATI
#ifndef GL_VERTEX_STREAM1_ATI
#define GL_VERTEX_STREAM1_ATI                                           0x876D
#endif //GL_VERTEX_STREAM1_ATI
#ifndef GL_VERTEX_STREAM2_ATI
#define GL_VERTEX_STREAM2_ATI                                           0x876E
#endif //GL_VERTEX_STREAM2_ATI
#ifndef GL_VERTEX_STREAM3_ATI
#define GL_VERTEX_STREAM3_ATI                                           0x876F
#endif //GL_VERTEX_STREAM3_ATI
#ifndef GL_VERTEX_STREAM4_ATI
#define GL_VERTEX_STREAM4_ATI                                           0x8770
#endif //GL_VERTEX_STREAM4_ATI
#ifndef GL_VERTEX_STREAM5_ATI
#define GL_VERTEX_STREAM5_ATI                                           0x8771
#endif //GL_VERTEX_STREAM5_ATI
#ifndef GL_VERTEX_STREAM6_ATI
#define GL_VERTEX_STREAM6_ATI                                           0x8772
#endif //GL_VERTEX_STREAM6_ATI
#ifndef GL_VERTEX_STREAM7_ATI
#define GL_VERTEX_STREAM7_ATI                                           0x8773
#endif //GL_VERTEX_STREAM7_ATI
#ifndef GL_VERTEX_SOURCE_ATI
#define GL_VERTEX_SOURCE_ATI                                            0x8774
#endif //GL_VERTEX_SOURCE_ATI

#endif //GL_ATI_vertex_streams


typedef void (*PFNVERTEXSTREAM1SATIPROC_HPP)(GLenum stream,GLshort x);

static inline void VertexStream1sATI(GLenum stream,GLshort x)
{
	static PFNVERTEXSTREAM1SATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1SATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1sATI","GL_ATI_vertex_streams"));
	 fn(stream,x);
}

typedef void (*PFNVERTEXSTREAM1SVATIPROC_HPP)(GLenum stream,const GLshort *coords);

static inline void VertexStream1svATI(GLenum stream,const GLshort *coords)
{
	static PFNVERTEXSTREAM1SVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1SVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1svATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM1IATIPROC_HPP)(GLenum stream,GLint x);

static inline void VertexStream1iATI(GLenum stream,GLint x)
{
	static PFNVERTEXSTREAM1IATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1IATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1iATI","GL_ATI_vertex_streams"));
	 fn(stream,x);
}

typedef void (*PFNVERTEXSTREAM1IVATIPROC_HPP)(GLenum stream,const GLint *coords);

static inline void VertexStream1ivATI(GLenum stream,const GLint *coords)
{
	static PFNVERTEXSTREAM1IVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1IVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1ivATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM1FATIPROC_HPP)(GLenum stream,GLfloat x);

static inline void VertexStream1fATI(GLenum stream,GLfloat x)
{
	static PFNVERTEXSTREAM1FATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1FATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1fATI","GL_ATI_vertex_streams"));
	 fn(stream,x);
}

typedef void (*PFNVERTEXSTREAM1FVATIPROC_HPP)(GLenum stream,const GLfloat *coords);

static inline void VertexStream1fvATI(GLenum stream,const GLfloat *coords)
{
	static PFNVERTEXSTREAM1FVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1FVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1fvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM1DATIPROC_HPP)(GLenum stream,GLdouble x);

static inline void VertexStream1dATI(GLenum stream,GLdouble x)
{
	static PFNVERTEXSTREAM1DATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1DATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1dATI","GL_ATI_vertex_streams"));
	 fn(stream,x);
}

typedef void (*PFNVERTEXSTREAM1DVATIPROC_HPP)(GLenum stream,const GLdouble *coords);

static inline void VertexStream1dvATI(GLenum stream,const GLdouble *coords)
{
	static PFNVERTEXSTREAM1DVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM1DVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream1dvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM2SATIPROC_HPP)(GLenum stream,GLshort x,GLshort y);

static inline void VertexStream2sATI(GLenum stream,GLshort x,GLshort y)
{
	static PFNVERTEXSTREAM2SATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2SATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2sATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y);
}

typedef void (*PFNVERTEXSTREAM2SVATIPROC_HPP)(GLenum stream,const GLshort *coords);

static inline void VertexStream2svATI(GLenum stream,const GLshort *coords)
{
	static PFNVERTEXSTREAM2SVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2SVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2svATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM2IATIPROC_HPP)(GLenum stream,GLint x,GLint y);

static inline void VertexStream2iATI(GLenum stream,GLint x,GLint y)
{
	static PFNVERTEXSTREAM2IATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2IATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2iATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y);
}

typedef void (*PFNVERTEXSTREAM2IVATIPROC_HPP)(GLenum stream,const GLint *coords);

static inline void VertexStream2ivATI(GLenum stream,const GLint *coords)
{
	static PFNVERTEXSTREAM2IVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2IVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2ivATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM2FATIPROC_HPP)(GLenum stream,GLfloat x,GLfloat y);

static inline void VertexStream2fATI(GLenum stream,GLfloat x,GLfloat y)
{
	static PFNVERTEXSTREAM2FATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2FATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2fATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y);
}

typedef void (*PFNVERTEXSTREAM2FVATIPROC_HPP)(GLenum stream,const GLfloat *coords);

static inline void VertexStream2fvATI(GLenum stream,const GLfloat *coords)
{
	static PFNVERTEXSTREAM2FVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2FVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2fvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM2DATIPROC_HPP)(GLenum stream,GLdouble x,GLdouble y);

static inline void VertexStream2dATI(GLenum stream,GLdouble x,GLdouble y)
{
	static PFNVERTEXSTREAM2DATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2DATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2dATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y);
}

typedef void (*PFNVERTEXSTREAM2DVATIPROC_HPP)(GLenum stream,const GLdouble *coords);

static inline void VertexStream2dvATI(GLenum stream,const GLdouble *coords)
{
	static PFNVERTEXSTREAM2DVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM2DVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream2dvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM3SATIPROC_HPP)(GLenum stream,GLshort x,GLshort y,GLshort z);

static inline void VertexStream3sATI(GLenum stream,GLshort x,GLshort y,GLshort z)
{
	static PFNVERTEXSTREAM3SATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3SATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3sATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z);
}

typedef void (*PFNVERTEXSTREAM3SVATIPROC_HPP)(GLenum stream,const GLshort *coords);

static inline void VertexStream3svATI(GLenum stream,const GLshort *coords)
{
	static PFNVERTEXSTREAM3SVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3SVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3svATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM3IATIPROC_HPP)(GLenum stream,GLint x,GLint y,GLint z);

static inline void VertexStream3iATI(GLenum stream,GLint x,GLint y,GLint z)
{
	static PFNVERTEXSTREAM3IATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3IATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3iATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z);
}

typedef void (*PFNVERTEXSTREAM3IVATIPROC_HPP)(GLenum stream,const GLint *coords);

static inline void VertexStream3ivATI(GLenum stream,const GLint *coords)
{
	static PFNVERTEXSTREAM3IVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3IVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3ivATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM3FATIPROC_HPP)(GLenum stream,GLfloat x,GLfloat y,GLfloat z);

static inline void VertexStream3fATI(GLenum stream,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNVERTEXSTREAM3FATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3FATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3fATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z);
}

typedef void (*PFNVERTEXSTREAM3FVATIPROC_HPP)(GLenum stream,const GLfloat *coords);

static inline void VertexStream3fvATI(GLenum stream,const GLfloat *coords)
{
	static PFNVERTEXSTREAM3FVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3FVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3fvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM3DATIPROC_HPP)(GLenum stream,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexStream3dATI(GLenum stream,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXSTREAM3DATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3DATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3dATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z);
}

typedef void (*PFNVERTEXSTREAM3DVATIPROC_HPP)(GLenum stream,const GLdouble *coords);

static inline void VertexStream3dvATI(GLenum stream,const GLdouble *coords)
{
	static PFNVERTEXSTREAM3DVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM3DVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream3dvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM4SATIPROC_HPP)(GLenum stream,GLshort x,GLshort y,GLshort z,GLshort w);

static inline void VertexStream4sATI(GLenum stream,GLshort x,GLshort y,GLshort z,GLshort w)
{
	static PFNVERTEXSTREAM4SATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4SATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4sATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z,w);
}

typedef void (*PFNVERTEXSTREAM4SVATIPROC_HPP)(GLenum stream,const GLshort *coords);

static inline void VertexStream4svATI(GLenum stream,const GLshort *coords)
{
	static PFNVERTEXSTREAM4SVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4SVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4svATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM4IATIPROC_HPP)(GLenum stream,GLint x,GLint y,GLint z,GLint w);

static inline void VertexStream4iATI(GLenum stream,GLint x,GLint y,GLint z,GLint w)
{
	static PFNVERTEXSTREAM4IATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4IATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4iATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z,w);
}

typedef void (*PFNVERTEXSTREAM4IVATIPROC_HPP)(GLenum stream,const GLint *coords);

static inline void VertexStream4ivATI(GLenum stream,const GLint *coords)
{
	static PFNVERTEXSTREAM4IVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4IVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4ivATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM4FATIPROC_HPP)(GLenum stream,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void VertexStream4fATI(GLenum stream,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNVERTEXSTREAM4FATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4FATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4fATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z,w);
}

typedef void (*PFNVERTEXSTREAM4FVATIPROC_HPP)(GLenum stream,const GLfloat *coords);

static inline void VertexStream4fvATI(GLenum stream,const GLfloat *coords)
{
	static PFNVERTEXSTREAM4FVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4FVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4fvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNVERTEXSTREAM4DATIPROC_HPP)(GLenum stream,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexStream4dATI(GLenum stream,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXSTREAM4DATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4DATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4dATI","GL_ATI_vertex_streams"));
	 fn(stream,x,y,z,w);
}

typedef void (*PFNVERTEXSTREAM4DVATIPROC_HPP)(GLenum stream,const GLdouble *coords);

static inline void VertexStream4dvATI(GLenum stream,const GLdouble *coords)
{
	static PFNVERTEXSTREAM4DVATIPROC_HPP fn=reinterpret_cast<PFNVERTEXSTREAM4DVATIPROC_HPP>(_impl::_get_proc_address("glVertexStream4dvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNNORMALSTREAM3BATIPROC_HPP)(GLenum stream,GLbyte nx,GLbyte ny,GLbyte nz);

static inline void NormalStream3bATI(GLenum stream,GLbyte nx,GLbyte ny,GLbyte nz)
{
	static PFNNORMALSTREAM3BATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3BATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3bATI","GL_ATI_vertex_streams"));
	 fn(stream,nx,ny,nz);
}

typedef void (*PFNNORMALSTREAM3BVATIPROC_HPP)(GLenum stream,const GLbyte *coords);

static inline void NormalStream3bvATI(GLenum stream,const GLbyte *coords)
{
	static PFNNORMALSTREAM3BVATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3BVATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3bvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNNORMALSTREAM3SATIPROC_HPP)(GLenum stream,GLshort nx,GLshort ny,GLshort nz);

static inline void NormalStream3sATI(GLenum stream,GLshort nx,GLshort ny,GLshort nz)
{
	static PFNNORMALSTREAM3SATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3SATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3sATI","GL_ATI_vertex_streams"));
	 fn(stream,nx,ny,nz);
}

typedef void (*PFNNORMALSTREAM3SVATIPROC_HPP)(GLenum stream,const GLshort *coords);

static inline void NormalStream3svATI(GLenum stream,const GLshort *coords)
{
	static PFNNORMALSTREAM3SVATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3SVATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3svATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNNORMALSTREAM3IATIPROC_HPP)(GLenum stream,GLint nx,GLint ny,GLint nz);

static inline void NormalStream3iATI(GLenum stream,GLint nx,GLint ny,GLint nz)
{
	static PFNNORMALSTREAM3IATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3IATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3iATI","GL_ATI_vertex_streams"));
	 fn(stream,nx,ny,nz);
}

typedef void (*PFNNORMALSTREAM3IVATIPROC_HPP)(GLenum stream,const GLint *coords);

static inline void NormalStream3ivATI(GLenum stream,const GLint *coords)
{
	static PFNNORMALSTREAM3IVATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3IVATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3ivATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNNORMALSTREAM3FATIPROC_HPP)(GLenum stream,GLfloat nx,GLfloat ny,GLfloat nz);

static inline void NormalStream3fATI(GLenum stream,GLfloat nx,GLfloat ny,GLfloat nz)
{
	static PFNNORMALSTREAM3FATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3FATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3fATI","GL_ATI_vertex_streams"));
	 fn(stream,nx,ny,nz);
}

typedef void (*PFNNORMALSTREAM3FVATIPROC_HPP)(GLenum stream,const GLfloat *coords);

static inline void NormalStream3fvATI(GLenum stream,const GLfloat *coords)
{
	static PFNNORMALSTREAM3FVATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3FVATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3fvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNNORMALSTREAM3DATIPROC_HPP)(GLenum stream,GLdouble nx,GLdouble ny,GLdouble nz);

static inline void NormalStream3dATI(GLenum stream,GLdouble nx,GLdouble ny,GLdouble nz)
{
	static PFNNORMALSTREAM3DATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3DATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3dATI","GL_ATI_vertex_streams"));
	 fn(stream,nx,ny,nz);
}

typedef void (*PFNNORMALSTREAM3DVATIPROC_HPP)(GLenum stream,const GLdouble *coords);

static inline void NormalStream3dvATI(GLenum stream,const GLdouble *coords)
{
	static PFNNORMALSTREAM3DVATIPROC_HPP fn=reinterpret_cast<PFNNORMALSTREAM3DVATIPROC_HPP>(_impl::_get_proc_address("glNormalStream3dvATI","GL_ATI_vertex_streams"));
	 fn(stream,coords);
}

typedef void (*PFNCLIENTACTIVEVERTEXSTREAMATIPROC_HPP)(GLenum stream);

static inline void ClientActiveVertexStreamATI(GLenum stream)
{
	static PFNCLIENTACTIVEVERTEXSTREAMATIPROC_HPP fn=reinterpret_cast<PFNCLIENTACTIVEVERTEXSTREAMATIPROC_HPP>(_impl::_get_proc_address("glClientActiveVertexStreamATI","GL_ATI_vertex_streams"));
	 fn(stream);
}

typedef void (*PFNVERTEXBLENDENVIATIPROC_HPP)(GLenum pname,GLint param);

static inline void VertexBlendEnviATI(GLenum pname,GLint param)
{
	static PFNVERTEXBLENDENVIATIPROC_HPP fn=reinterpret_cast<PFNVERTEXBLENDENVIATIPROC_HPP>(_impl::_get_proc_address("glVertexBlendEnviATI","GL_ATI_vertex_streams"));
	 fn(pname,param);
}

typedef void (*PFNVERTEXBLENDENVFATIPROC_HPP)(GLenum pname,GLfloat param);

static inline void VertexBlendEnvfATI(GLenum pname,GLfloat param)
{
	static PFNVERTEXBLENDENVFATIPROC_HPP fn=reinterpret_cast<PFNVERTEXBLENDENVFATIPROC_HPP>(_impl::_get_proc_address("glVertexBlendEnvfATI","GL_ATI_vertex_streams"));
	 fn(pname,param);
}
#ifndef GL_AccumOp

#define GL_AccumOp
#ifndef GL_ACCUM
#define GL_ACCUM                                                        0x0100
#endif //GL_ACCUM
#ifndef GL_LOAD
#define GL_LOAD                                                         0x0101
#endif //GL_LOAD
#ifndef GL_RETURN
#define GL_RETURN                                                       0x0102
#endif //GL_RETURN
#ifndef GL_MULT
#define GL_MULT                                                         0x0103
#endif //GL_MULT
#ifndef GL_ADD
#define GL_ADD                                                          0x0104
#endif //GL_ADD

#endif //GL_AccumOp

#ifndef GL_AlphaFunction

#define GL_AlphaFunction
#ifndef GL_NEVER
#define GL_NEVER                                                        0x0200
#endif //GL_NEVER
#ifndef GL_LESS
#define GL_LESS                                                         0x0201
#endif //GL_LESS
#ifndef GL_EQUAL
#define GL_EQUAL                                                        0x0202
#endif //GL_EQUAL
#ifndef GL_LEQUAL
#define GL_LEQUAL                                                       0x0203
#endif //GL_LEQUAL
#ifndef GL_GREATER
#define GL_GREATER                                                      0x0204
#endif //GL_GREATER
#ifndef GL_NOTEQUAL
#define GL_NOTEQUAL                                                     0x0205
#endif //GL_NOTEQUAL
#ifndef GL_GEQUAL
#define GL_GEQUAL                                                       0x0206
#endif //GL_GEQUAL
#ifndef GL_ALWAYS
#define GL_ALWAYS                                                       0x0207
#endif //GL_ALWAYS

#endif //GL_AlphaFunction

#ifndef GL_AttribMask

#define GL_AttribMask
#ifndef GL_CURRENT_BIT
#define GL_CURRENT_BIT                                                  0x00000001
#endif //GL_CURRENT_BIT
#ifndef GL_POINT_BIT
#define GL_POINT_BIT                                                    0x00000002
#endif //GL_POINT_BIT
#ifndef GL_LINE_BIT
#define GL_LINE_BIT                                                     0x00000004
#endif //GL_LINE_BIT
#ifndef GL_POLYGON_BIT
#define GL_POLYGON_BIT                                                  0x00000008
#endif //GL_POLYGON_BIT
#ifndef GL_POLYGON_STIPPLE_BIT
#define GL_POLYGON_STIPPLE_BIT                                          0x00000010
#endif //GL_POLYGON_STIPPLE_BIT
#ifndef GL_PIXEL_MODE_BIT
#define GL_PIXEL_MODE_BIT                                               0x00000020
#endif //GL_PIXEL_MODE_BIT
#ifndef GL_LIGHTING_BIT
#define GL_LIGHTING_BIT                                                 0x00000040
#endif //GL_LIGHTING_BIT
#ifndef GL_FOG_BIT
#define GL_FOG_BIT                                                      0x00000080
#endif //GL_FOG_BIT
#ifndef GL_DEPTH_BUFFER_BIT
#define GL_DEPTH_BUFFER_BIT                                             0x00000100
#endif //GL_DEPTH_BUFFER_BIT
#ifndef GL_ACCUM_BUFFER_BIT
#define GL_ACCUM_BUFFER_BIT                                             0x00000200
#endif //GL_ACCUM_BUFFER_BIT
#ifndef GL_STENCIL_BUFFER_BIT
#define GL_STENCIL_BUFFER_BIT                                           0x00000400
#endif //GL_STENCIL_BUFFER_BIT
#ifndef GL_VIEWPORT_BIT
#define GL_VIEWPORT_BIT                                                 0x00000800
#endif //GL_VIEWPORT_BIT
#ifndef GL_TRANSFORM_BIT
#define GL_TRANSFORM_BIT                                                0x00001000
#endif //GL_TRANSFORM_BIT
#ifndef GL_ENABLE_BIT
#define GL_ENABLE_BIT                                                   0x00002000
#endif //GL_ENABLE_BIT
#ifndef GL_COLOR_BUFFER_BIT
#define GL_COLOR_BUFFER_BIT                                             0x00004000
#endif //GL_COLOR_BUFFER_BIT
#ifndef GL_HINT_BIT
#define GL_HINT_BIT                                                     0x00008000
#endif //GL_HINT_BIT
#ifndef GL_EVAL_BIT
#define GL_EVAL_BIT                                                     0x00010000
#endif //GL_EVAL_BIT
#ifndef GL_LIST_BIT
#define GL_LIST_BIT                                                     0x00020000
#endif //GL_LIST_BIT
#ifndef GL_TEXTURE_BIT
#define GL_TEXTURE_BIT                                                  0x00040000
#endif //GL_TEXTURE_BIT
#ifndef GL_SCISSOR_BIT
#define GL_SCISSOR_BIT                                                  0x00080000
#endif //GL_SCISSOR_BIT
#ifndef GL_ALL_ATTRIB_BITS
#define GL_ALL_ATTRIB_BITS                                              0xFFFFFFFF
#endif //GL_ALL_ATTRIB_BITS

#endif //GL_AttribMask

#ifndef GL_BeginMode

#define GL_BeginMode
#ifndef GL_POINTS
#define GL_POINTS                                                       0x0000
#endif //GL_POINTS
#ifndef GL_LINES
#define GL_LINES                                                        0x0001
#endif //GL_LINES
#ifndef GL_LINE_LOOP
#define GL_LINE_LOOP                                                    0x0002
#endif //GL_LINE_LOOP
#ifndef GL_LINE_STRIP
#define GL_LINE_STRIP                                                   0x0003
#endif //GL_LINE_STRIP
#ifndef GL_TRIANGLES
#define GL_TRIANGLES                                                    0x0004
#endif //GL_TRIANGLES
#ifndef GL_TRIANGLE_STRIP
#define GL_TRIANGLE_STRIP                                               0x0005
#endif //GL_TRIANGLE_STRIP
#ifndef GL_TRIANGLE_FAN
#define GL_TRIANGLE_FAN                                                 0x0006
#endif //GL_TRIANGLE_FAN
#ifndef GL_QUADS
#define GL_QUADS                                                        0x0007
#endif //GL_QUADS
#ifndef GL_QUAD_STRIP
#define GL_QUAD_STRIP                                                   0x0008
#endif //GL_QUAD_STRIP
#ifndef GL_POLYGON
#define GL_POLYGON                                                      0x0009
#endif //GL_POLYGON

#endif //GL_BeginMode

#ifndef GL_BlendEquationModeEXT

#define GL_BlendEquationModeEXT
#ifndef GL_LOGIC_OP
#define GL_LOGIC_OP                                                     0x0BF1
#endif //GL_LOGIC_OP
#ifndef GL_FUNC_ADD_EXT
#define GL_FUNC_ADD_EXT                                                 0x8006
#endif //GL_FUNC_ADD_EXT
#ifndef GL_MIN_EXT
#define GL_MIN_EXT                                                      0x8007
#endif //GL_MIN_EXT
#ifndef GL_MAX_EXT
#define GL_MAX_EXT                                                      0x8008
#endif //GL_MAX_EXT
#ifndef GL_FUNC_SUBTRACT_EXT
#define GL_FUNC_SUBTRACT_EXT                                            0x800A
#endif //GL_FUNC_SUBTRACT_EXT
#ifndef GL_FUNC_REVERSE_SUBTRACT_EXT
#define GL_FUNC_REVERSE_SUBTRACT_EXT                                    0x800B
#endif //GL_FUNC_REVERSE_SUBTRACT_EXT
#ifndef GL_ALPHA_MIN_SGIX
#define GL_ALPHA_MIN_SGIX                                               0x8320
#endif //GL_ALPHA_MIN_SGIX
#ifndef GL_ALPHA_MAX_SGIX
#define GL_ALPHA_MAX_SGIX                                               0x8321
#endif //GL_ALPHA_MAX_SGIX

#endif //GL_BlendEquationModeEXT

#ifndef GL_BlendingFactorDest

#define GL_BlendingFactorDest
#ifndef GL_ZERO
#define GL_ZERO                                                         0
#endif //GL_ZERO
#ifndef GL_SRC_COLOR
#define GL_SRC_COLOR                                                    0x0300
#endif //GL_SRC_COLOR
#ifndef GL_ONE_MINUS_SRC_COLOR
#define GL_ONE_MINUS_SRC_COLOR                                          0x0301
#endif //GL_ONE_MINUS_SRC_COLOR
#ifndef GL_SRC_ALPHA
#define GL_SRC_ALPHA                                                    0x0302
#endif //GL_SRC_ALPHA
#ifndef GL_ONE_MINUS_SRC_ALPHA
#define GL_ONE_MINUS_SRC_ALPHA                                          0x0303
#endif //GL_ONE_MINUS_SRC_ALPHA
#ifndef GL_DST_ALPHA
#define GL_DST_ALPHA                                                    0x0304
#endif //GL_DST_ALPHA
#ifndef GL_ONE_MINUS_DST_ALPHA
#define GL_ONE_MINUS_DST_ALPHA                                          0x0305
#endif //GL_ONE_MINUS_DST_ALPHA
#ifndef GL_CONSTANT_COLOR_EXT
#define GL_CONSTANT_COLOR_EXT                                           0x8001
#endif //GL_CONSTANT_COLOR_EXT
#ifndef GL_ONE_MINUS_CONSTANT_COLOR_EXT
#define GL_ONE_MINUS_CONSTANT_COLOR_EXT                                 0x8002
#endif //GL_ONE_MINUS_CONSTANT_COLOR_EXT
#ifndef GL_CONSTANT_ALPHA_EXT
#define GL_CONSTANT_ALPHA_EXT                                           0x8003
#endif //GL_CONSTANT_ALPHA_EXT
#ifndef GL_ONE_MINUS_CONSTANT_ALPHA_EXT
#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT                                 0x8004
#endif //GL_ONE_MINUS_CONSTANT_ALPHA_EXT
#ifndef GL_ONE
#define GL_ONE                                                          1
#endif //GL_ONE

#endif //GL_BlendingFactorDest

#ifndef GL_BlendingFactorSrc

#define GL_BlendingFactorSrc
#ifndef GL_DST_COLOR
#define GL_DST_COLOR                                                    0x0306
#endif //GL_DST_COLOR
#ifndef GL_ONE_MINUS_DST_COLOR
#define GL_ONE_MINUS_DST_COLOR                                          0x0307
#endif //GL_ONE_MINUS_DST_COLOR
#ifndef GL_SRC_ALPHA_SATURATE
#define GL_SRC_ALPHA_SATURATE                                           0x0308
#endif //GL_SRC_ALPHA_SATURATE

#endif //GL_BlendingFactorSrc

#ifndef GL_Boolean

#define GL_Boolean
#ifndef GL_FALSE
#define GL_FALSE                                                        0
#endif //GL_FALSE
#ifndef GL_TRUE
#define GL_TRUE                                                         1
#endif //GL_TRUE

#endif //GL_Boolean

#ifndef GL_ClearBufferMask

#define GL_ClearBufferMask
#ifndef GL_COVERAGE_BUFFER_BIT_NV
#define GL_COVERAGE_BUFFER_BIT_NV                                       0x00008000
#endif //GL_COVERAGE_BUFFER_BIT_NV

#endif //GL_ClearBufferMask

#ifndef GL_ClientAttribMask

#define GL_ClientAttribMask
#ifndef GL_CLIENT_PIXEL_STORE_BIT
#define GL_CLIENT_PIXEL_STORE_BIT                                       0x00000001
#endif //GL_CLIENT_PIXEL_STORE_BIT
#ifndef GL_CLIENT_VERTEX_ARRAY_BIT
#define GL_CLIENT_VERTEX_ARRAY_BIT                                      0x00000002
#endif //GL_CLIENT_VERTEX_ARRAY_BIT
#ifndef GL_CLIENT_ALL_ATTRIB_BITS
#define GL_CLIENT_ALL_ATTRIB_BITS                                       0xFFFFFFFF
#endif //GL_CLIENT_ALL_ATTRIB_BITS

#endif //GL_ClientAttribMask

#ifndef GL_ClipPlaneName

#define GL_ClipPlaneName

#endif //GL_ClipPlaneName

#ifndef GL_ColorMaterialFace

#define GL_ColorMaterialFace
#ifndef GL_FRONT
#define GL_FRONT                                                        0x0404
#endif //GL_FRONT
#ifndef GL_BACK
#define GL_BACK                                                         0x0405
#endif //GL_BACK
#ifndef GL_FRONT_AND_BACK
#define GL_FRONT_AND_BACK                                               0x0408
#endif //GL_FRONT_AND_BACK

#endif //GL_ColorMaterialFace

#ifndef GL_ColorMaterialParameter

#define GL_ColorMaterialParameter
#ifndef GL_AMBIENT
#define GL_AMBIENT                                                      0x1200
#endif //GL_AMBIENT
#ifndef GL_DIFFUSE
#define GL_DIFFUSE                                                      0x1201
#endif //GL_DIFFUSE
#ifndef GL_SPECULAR
#define GL_SPECULAR                                                     0x1202
#endif //GL_SPECULAR
#ifndef GL_EMISSION
#define GL_EMISSION                                                     0x1600
#endif //GL_EMISSION
#ifndef GL_AMBIENT_AND_DIFFUSE
#define GL_AMBIENT_AND_DIFFUSE                                          0x1602
#endif //GL_AMBIENT_AND_DIFFUSE

#endif //GL_ColorMaterialParameter

#ifndef GL_ColorPointerType

#define GL_ColorPointerType
#ifndef GL_BYTE
#define GL_BYTE                                                         0x1400
#endif //GL_BYTE
#ifndef GL_UNSIGNED_BYTE
#define GL_UNSIGNED_BYTE                                                0x1401
#endif //GL_UNSIGNED_BYTE
#ifndef GL_SHORT
#define GL_SHORT                                                        0x1402
#endif //GL_SHORT
#ifndef GL_UNSIGNED_SHORT
#define GL_UNSIGNED_SHORT                                               0x1403
#endif //GL_UNSIGNED_SHORT
#ifndef GL_INT
#define GL_INT                                                          0x1404
#endif //GL_INT
#ifndef GL_UNSIGNED_INT
#define GL_UNSIGNED_INT                                                 0x1405
#endif //GL_UNSIGNED_INT
#ifndef GL_FLOAT
#define GL_FLOAT                                                        0x1406
#endif //GL_FLOAT
#ifndef GL_DOUBLE
#define GL_DOUBLE                                                       0x140A
#endif //GL_DOUBLE

#endif //GL_ColorPointerType

#ifndef GL_ColorTableParameterPNameSGI

#define GL_ColorTableParameterPNameSGI
#ifndef GL_COLOR_TABLE_SCALE_SGI
#define GL_COLOR_TABLE_SCALE_SGI                                        0x80D6
#endif //GL_COLOR_TABLE_SCALE_SGI
#ifndef GL_COLOR_TABLE_BIAS_SGI
#define GL_COLOR_TABLE_BIAS_SGI                                         0x80D7
#endif //GL_COLOR_TABLE_BIAS_SGI

#endif //GL_ColorTableParameterPNameSGI

#ifndef GL_ColorTableTargetSGI

#define GL_ColorTableTargetSGI
#ifndef GL_TEXTURE_COLOR_TABLE_SGI
#define GL_TEXTURE_COLOR_TABLE_SGI                                      0x80BC
#endif //GL_TEXTURE_COLOR_TABLE_SGI
#ifndef GL_PROXY_TEXTURE_COLOR_TABLE_SGI
#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI                                0x80BD
#endif //GL_PROXY_TEXTURE_COLOR_TABLE_SGI
#ifndef GL_COLOR_TABLE_SGI
#define GL_COLOR_TABLE_SGI                                              0x80D0
#endif //GL_COLOR_TABLE_SGI
#ifndef GL_POST_CONVOLUTION_COLOR_TABLE_SGI
#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI                             0x80D1
#endif //GL_POST_CONVOLUTION_COLOR_TABLE_SGI
#ifndef GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI                            0x80D2
#endif //GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI
#ifndef GL_PROXY_COLOR_TABLE_SGI
#define GL_PROXY_COLOR_TABLE_SGI                                        0x80D3
#endif //GL_PROXY_COLOR_TABLE_SGI
#ifndef GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI
#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI                       0x80D4
#endif //GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI
#ifndef GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI
#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI                      0x80D5
#endif //GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI

#endif //GL_ColorTableTargetSGI

#ifndef GL_ConvolutionBorderModeEXT

#define GL_ConvolutionBorderModeEXT
#ifndef GL_REDUCE_EXT
#define GL_REDUCE_EXT                                                   0x8016
#endif //GL_REDUCE_EXT

#endif //GL_ConvolutionBorderModeEXT

#ifndef GL_ConvolutionParameterEXT

#define GL_ConvolutionParameterEXT
#ifndef GL_CONVOLUTION_BORDER_MODE_EXT
#define GL_CONVOLUTION_BORDER_MODE_EXT                                  0x8013
#endif //GL_CONVOLUTION_BORDER_MODE_EXT
#ifndef GL_CONVOLUTION_FILTER_SCALE_EXT
#define GL_CONVOLUTION_FILTER_SCALE_EXT                                 0x8014
#endif //GL_CONVOLUTION_FILTER_SCALE_EXT
#ifndef GL_CONVOLUTION_FILTER_BIAS_EXT
#define GL_CONVOLUTION_FILTER_BIAS_EXT                                  0x8015
#endif //GL_CONVOLUTION_FILTER_BIAS_EXT

#endif //GL_ConvolutionParameterEXT

#ifndef GL_ConvolutionTargetEXT

#define GL_ConvolutionTargetEXT
#ifndef GL_CONVOLUTION_1D_EXT
#define GL_CONVOLUTION_1D_EXT                                           0x8010
#endif //GL_CONVOLUTION_1D_EXT
#ifndef GL_CONVOLUTION_2D_EXT
#define GL_CONVOLUTION_2D_EXT                                           0x8011
#endif //GL_CONVOLUTION_2D_EXT

#endif //GL_ConvolutionTargetEXT

#ifndef GL_CullFaceMode

#define GL_CullFaceMode

#endif //GL_CullFaceMode

#ifndef GL_DMP_shader_binary

#define GL_DMP_shader_binary
#ifndef GL_SHADER_BINARY_DMP
#define GL_SHADER_BINARY_DMP                                            0x9250
#endif //GL_SHADER_BINARY_DMP

#endif //GL_DMP_shader_binary

#ifndef GL_DataType

#define GL_DataType
#ifndef GL_2_BYTES
#define GL_2_BYTES                                                      0x1407
#endif //GL_2_BYTES
#ifndef GL_3_BYTES
#define GL_3_BYTES                                                      0x1408
#endif //GL_3_BYTES
#ifndef GL_4_BYTES
#define GL_4_BYTES                                                      0x1409
#endif //GL_4_BYTES
#ifndef GL_DOUBLE_EXT
#define GL_DOUBLE_EXT                                                   0x140A
#endif //GL_DOUBLE_EXT

#endif //GL_DataType

#ifndef GL_DepthFunction

#define GL_DepthFunction

#endif //GL_DepthFunction

#ifndef GL_DrawBufferMode

#define GL_DrawBufferMode
#ifndef GL_FRONT_LEFT
#define GL_FRONT_LEFT                                                   0x0400
#endif //GL_FRONT_LEFT
#ifndef GL_FRONT_RIGHT
#define GL_FRONT_RIGHT                                                  0x0401
#endif //GL_FRONT_RIGHT
#ifndef GL_BACK_LEFT
#define GL_BACK_LEFT                                                    0x0402
#endif //GL_BACK_LEFT
#ifndef GL_BACK_RIGHT
#define GL_BACK_RIGHT                                                   0x0403
#endif //GL_BACK_RIGHT
#ifndef GL_LEFT
#define GL_LEFT                                                         0x0406
#endif //GL_LEFT
#ifndef GL_RIGHT
#define GL_RIGHT                                                        0x0407
#endif //GL_RIGHT
#ifndef GL_AUX0
#define GL_AUX0                                                         0x0409
#endif //GL_AUX0
#ifndef GL_AUX1
#define GL_AUX1                                                         0x040A
#endif //GL_AUX1
#ifndef GL_AUX2
#define GL_AUX2                                                         0x040B
#endif //GL_AUX2
#ifndef GL_AUX3
#define GL_AUX3                                                         0x040C
#endif //GL_AUX3

#endif //GL_DrawBufferMode

#ifndef GL_EXT_422_pixels

#define GL_EXT_422_pixels
#ifndef GL_422_EXT
#define GL_422_EXT                                                      0x80CC
#endif //GL_422_EXT
#ifndef GL_422_REV_EXT
#define GL_422_REV_EXT                                                  0x80CD
#endif //GL_422_REV_EXT
#ifndef GL_422_AVERAGE_EXT
#define GL_422_AVERAGE_EXT                                              0x80CE
#endif //GL_422_AVERAGE_EXT
#ifndef GL_422_REV_AVERAGE_EXT
#define GL_422_REV_AVERAGE_EXT                                          0x80CF
#endif //GL_422_REV_AVERAGE_EXT

#endif //GL_EXT_422_pixels

#ifndef GL_EXT_abgr

#define GL_EXT_abgr
#ifndef GL_ABGR_EXT
#define GL_ABGR_EXT                                                     0x8000
#endif //GL_ABGR_EXT

#endif //GL_EXT_abgr

#ifndef GL_EXT_bgra

#define GL_EXT_bgra
#ifndef GL_BGR_EXT
#define GL_BGR_EXT                                                      0x80E0
#endif //GL_BGR_EXT
#ifndef GL_BGRA_EXT
#define GL_BGRA_EXT                                                     0x80E1
#endif //GL_BGRA_EXT

#endif //GL_EXT_bgra

#ifndef GL_EXT_bindable_uniform

#define GL_EXT_bindable_uniform
#ifndef GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT
#define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT                             0x8DE2
#endif //GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT
#ifndef GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT
#define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT                           0x8DE3
#endif //GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT
#ifndef GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT
#define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT                           0x8DE4
#endif //GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT
#ifndef GL_MAX_BINDABLE_UNIFORM_SIZE_EXT
#define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT                                0x8DED
#endif //GL_MAX_BINDABLE_UNIFORM_SIZE_EXT
#ifndef GL_UNIFORM_BUFFER_EXT
#define GL_UNIFORM_BUFFER_EXT                                           0x8DEE
#endif //GL_UNIFORM_BUFFER_EXT
#ifndef GL_UNIFORM_BUFFER_BINDING_EXT
#define GL_UNIFORM_BUFFER_BINDING_EXT                                   0x8DEF
#endif //GL_UNIFORM_BUFFER_BINDING_EXT

#endif //GL_EXT_bindable_uniform


typedef void (*PFNUNIFORMBUFFEREXTPROC_HPP)(GLuint program,GLint location,GLuint buffer);

static inline void UniformBufferEXT(GLuint program,GLint location,GLuint buffer)
{
	static PFNUNIFORMBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNUNIFORMBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glUniformBufferEXT","GL_EXT_bindable_uniform"));
	 fn(program,location,buffer);
}

typedef GLint (*PFNGETUNIFORMBUFFERSIZEEXTPROC_HPP)(GLuint program,GLint location);

static inline GLint GetUniformBufferSizeEXT(GLuint program,GLint location)
{
	static PFNGETUNIFORMBUFFERSIZEEXTPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMBUFFERSIZEEXTPROC_HPP>(_impl::_get_proc_address("glGetUniformBufferSizeEXT","GL_EXT_bindable_uniform"));
	return fn(program,location);
}

typedef GLintptr (*PFNGETUNIFORMOFFSETEXTPROC_HPP)(GLuint program,GLint location);

static inline GLintptr GetUniformOffsetEXT(GLuint program,GLint location)
{
	static PFNGETUNIFORMOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glGetUniformOffsetEXT","GL_EXT_bindable_uniform"));
	return fn(program,location);
}
#ifndef GL_EXT_blend_color

#define GL_EXT_blend_color
#ifndef GL_BLEND_COLOR_EXT
#define GL_BLEND_COLOR_EXT                                              0x8005
#endif //GL_BLEND_COLOR_EXT

#endif //GL_EXT_blend_color


typedef void (*PFNBLENDCOLOREXTPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha);

static inline void BlendColorEXT(GLfloat red,GLfloat green,GLfloat blue,GLfloat alpha)
{
	static PFNBLENDCOLOREXTPROC_HPP fn=reinterpret_cast<PFNBLENDCOLOREXTPROC_HPP>(_impl::_get_proc_address("glBlendColorEXT","GL_EXT_blend_color"));
	 fn(red,green,blue,alpha);
}
#ifndef GL_EXT_blend_equation_separate

#define GL_EXT_blend_equation_separate
#ifndef GL_BLEND_EQUATION_RGB_EXT
#define GL_BLEND_EQUATION_RGB_EXT                                       0x8009
#endif //GL_BLEND_EQUATION_RGB_EXT
#ifndef GL_BLEND_EQUATION_ALPHA_EXT
#define GL_BLEND_EQUATION_ALPHA_EXT                                     0x883D
#endif //GL_BLEND_EQUATION_ALPHA_EXT

#endif //GL_EXT_blend_equation_separate


typedef void (*PFNBLENDEQUATIONSEPARATEEXTPROC_HPP)(GLenum modeRGB,GLenum modeAlpha);

static inline void BlendEquationSeparateEXT(GLenum modeRGB,GLenum modeAlpha)
{
	static PFNBLENDEQUATIONSEPARATEEXTPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONSEPARATEEXTPROC_HPP>(_impl::_get_proc_address("glBlendEquationSeparateEXT","GL_EXT_blend_equation_separate"));
	 fn(modeRGB,modeAlpha);
}
#ifndef GL_EXT_blend_func_separate

#define GL_EXT_blend_func_separate
#ifndef GL_BLEND_DST_RGB_EXT
#define GL_BLEND_DST_RGB_EXT                                            0x80C8
#endif //GL_BLEND_DST_RGB_EXT
#ifndef GL_BLEND_SRC_RGB_EXT
#define GL_BLEND_SRC_RGB_EXT                                            0x80C9
#endif //GL_BLEND_SRC_RGB_EXT
#ifndef GL_BLEND_DST_ALPHA_EXT
#define GL_BLEND_DST_ALPHA_EXT                                          0x80CA
#endif //GL_BLEND_DST_ALPHA_EXT
#ifndef GL_BLEND_SRC_ALPHA_EXT
#define GL_BLEND_SRC_ALPHA_EXT                                          0x80CB
#endif //GL_BLEND_SRC_ALPHA_EXT

#endif //GL_EXT_blend_func_separate


typedef void (*PFNBLENDFUNCSEPARATEEXTPROC_HPP)(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);

static inline void BlendFuncSeparateEXT(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)
{
	static PFNBLENDFUNCSEPARATEEXTPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEEXTPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparateEXT","GL_EXT_blend_func_separate"));
	 fn(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha);
}
#ifndef GL_EXT_blend_minmax

#define GL_EXT_blend_minmax
#ifndef GL_FUNC_ADD
#define GL_FUNC_ADD                                                     0x8006
#endif //GL_FUNC_ADD
#ifndef GL_MIN
#define GL_MIN                                                          0x8007
#endif //GL_MIN
#ifndef GL_MAX
#define GL_MAX                                                          0x8008
#endif //GL_MAX
#ifndef GL_BLEND_EQUATION_EXT
#define GL_BLEND_EQUATION_EXT                                           0x8009
#endif //GL_BLEND_EQUATION_EXT

#endif //GL_EXT_blend_minmax


typedef void (*PFNBLENDEQUATIONEXTPROC_HPP)(GLenum mode);

static inline void BlendEquationEXT(GLenum mode)
{
	static PFNBLENDEQUATIONEXTPROC_HPP fn=reinterpret_cast<PFNBLENDEQUATIONEXTPROC_HPP>(_impl::_get_proc_address("glBlendEquationEXT","GL_EXT_blend_minmax"));
	 fn(mode);
}
#ifndef GL_EXT_blend_subtract

#define GL_EXT_blend_subtract
#ifndef GL_FUNC_SUBTRACT
#define GL_FUNC_SUBTRACT                                                0x800A
#endif //GL_FUNC_SUBTRACT
#ifndef GL_FUNC_REVERSE_SUBTRACT
#define GL_FUNC_REVERSE_SUBTRACT                                        0x800B
#endif //GL_FUNC_REVERSE_SUBTRACT

#endif //GL_EXT_blend_subtract

#ifndef GL_EXT_cmyka

#define GL_EXT_cmyka
#ifndef GL_CMYK_EXT
#define GL_CMYK_EXT                                                     0x800C
#endif //GL_CMYK_EXT
#ifndef GL_CMYKA_EXT
#define GL_CMYKA_EXT                                                    0x800D
#endif //GL_CMYKA_EXT
#ifndef GL_PACK_CMYK_HINT_EXT
#define GL_PACK_CMYK_HINT_EXT                                           0x800E
#endif //GL_PACK_CMYK_HINT_EXT
#ifndef GL_UNPACK_CMYK_HINT_EXT
#define GL_UNPACK_CMYK_HINT_EXT                                         0x800F
#endif //GL_UNPACK_CMYK_HINT_EXT

#endif //GL_EXT_cmyka

#ifndef GL_EXT_color_buffer_half_float

#define GL_EXT_color_buffer_half_float
#ifndef GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT                    0x8211
#endif //GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT
#ifndef GL_R16F_EXT
#define GL_R16F_EXT                                                     0x822D
#endif //GL_R16F_EXT
#ifndef GL_RG16F_EXT
#define GL_RG16F_EXT                                                    0x822F
#endif //GL_RG16F_EXT
#ifndef GL_RGBA16F_EXT
#define GL_RGBA16F_EXT                                                  0x881A
#endif //GL_RGBA16F_EXT
#ifndef GL_RGB16F_EXT
#define GL_RGB16F_EXT                                                   0x881B
#endif //GL_RGB16F_EXT
#ifndef GL_UNSIGNED_NORMALIZED_EXT
#define GL_UNSIGNED_NORMALIZED_EXT                                      0x8C17
#endif //GL_UNSIGNED_NORMALIZED_EXT

#endif //GL_EXT_color_buffer_half_float

#ifndef GL_EXT_color_subtable

#define GL_EXT_color_subtable

#endif //GL_EXT_color_subtable


typedef void (*PFNCOLORSUBTABLEEXTPROC_HPP)(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const GLvoid *data);

static inline void ColorSubTableEXT(GLenum target,GLsizei start,GLsizei count,GLenum format,GLenum type,const GLvoid *data)
{
	static PFNCOLORSUBTABLEEXTPROC_HPP fn=reinterpret_cast<PFNCOLORSUBTABLEEXTPROC_HPP>(_impl::_get_proc_address("glColorSubTableEXT","GL_EXT_color_subtable"));
	 fn(target,start,count,format,type,data);
}

typedef void (*PFNCOPYCOLORSUBTABLEEXTPROC_HPP)(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width);

static inline void CopyColorSubTableEXT(GLenum target,GLsizei start,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCOLORSUBTABLEEXTPROC_HPP fn=reinterpret_cast<PFNCOPYCOLORSUBTABLEEXTPROC_HPP>(_impl::_get_proc_address("glCopyColorSubTableEXT","GL_EXT_color_subtable"));
	 fn(target,start,x,y,width);
}
#ifndef GL_EXT_compiled_vertex_array

#define GL_EXT_compiled_vertex_array
#ifndef GL_ARRAY_ELEMENT_LOCK_FIRST_EXT
#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT                                 0x81A8
#endif //GL_ARRAY_ELEMENT_LOCK_FIRST_EXT
#ifndef GL_ARRAY_ELEMENT_LOCK_COUNT_EXT
#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT                                 0x81A9
#endif //GL_ARRAY_ELEMENT_LOCK_COUNT_EXT

#endif //GL_EXT_compiled_vertex_array


typedef void (*PFNLOCKARRAYSEXTPROC_HPP)(GLint first,GLsizei count);

static inline void LockArraysEXT(GLint first,GLsizei count)
{
	static PFNLOCKARRAYSEXTPROC_HPP fn=reinterpret_cast<PFNLOCKARRAYSEXTPROC_HPP>(_impl::_get_proc_address("glLockArraysEXT","GL_EXT_compiled_vertex_array"));
	 fn(first,count);
}

typedef void (*PFNUNLOCKARRAYSEXTPROC_HPP)();

static inline void UnlockArraysEXT()
{
	static PFNUNLOCKARRAYSEXTPROC_HPP fn=reinterpret_cast<PFNUNLOCKARRAYSEXTPROC_HPP>(_impl::_get_proc_address("glUnlockArraysEXT","GL_EXT_compiled_vertex_array"));
	 fn();
}
#ifndef GL_EXT_convolution

#define GL_EXT_convolution
#ifndef GL_SEPARABLE_2D_EXT
#define GL_SEPARABLE_2D_EXT                                             0x8012
#endif //GL_SEPARABLE_2D_EXT
#ifndef GL_CONVOLUTION_FORMAT_EXT
#define GL_CONVOLUTION_FORMAT_EXT                                       0x8017
#endif //GL_CONVOLUTION_FORMAT_EXT
#ifndef GL_CONVOLUTION_WIDTH_EXT
#define GL_CONVOLUTION_WIDTH_EXT                                        0x8018
#endif //GL_CONVOLUTION_WIDTH_EXT
#ifndef GL_CONVOLUTION_HEIGHT_EXT
#define GL_CONVOLUTION_HEIGHT_EXT                                       0x8019
#endif //GL_CONVOLUTION_HEIGHT_EXT
#ifndef GL_MAX_CONVOLUTION_WIDTH_EXT
#define GL_MAX_CONVOLUTION_WIDTH_EXT                                    0x801A
#endif //GL_MAX_CONVOLUTION_WIDTH_EXT
#ifndef GL_MAX_CONVOLUTION_HEIGHT_EXT
#define GL_MAX_CONVOLUTION_HEIGHT_EXT                                   0x801B
#endif //GL_MAX_CONVOLUTION_HEIGHT_EXT
#ifndef GL_POST_CONVOLUTION_RED_SCALE_EXT
#define GL_POST_CONVOLUTION_RED_SCALE_EXT                               0x801C
#endif //GL_POST_CONVOLUTION_RED_SCALE_EXT
#ifndef GL_POST_CONVOLUTION_GREEN_SCALE_EXT
#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT                             0x801D
#endif //GL_POST_CONVOLUTION_GREEN_SCALE_EXT
#ifndef GL_POST_CONVOLUTION_BLUE_SCALE_EXT
#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT                              0x801E
#endif //GL_POST_CONVOLUTION_BLUE_SCALE_EXT
#ifndef GL_POST_CONVOLUTION_ALPHA_SCALE_EXT
#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT                             0x801F
#endif //GL_POST_CONVOLUTION_ALPHA_SCALE_EXT
#ifndef GL_POST_CONVOLUTION_RED_BIAS_EXT
#define GL_POST_CONVOLUTION_RED_BIAS_EXT                                0x8020
#endif //GL_POST_CONVOLUTION_RED_BIAS_EXT
#ifndef GL_POST_CONVOLUTION_GREEN_BIAS_EXT
#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT                              0x8021
#endif //GL_POST_CONVOLUTION_GREEN_BIAS_EXT
#ifndef GL_POST_CONVOLUTION_BLUE_BIAS_EXT
#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT                               0x8022
#endif //GL_POST_CONVOLUTION_BLUE_BIAS_EXT
#ifndef GL_POST_CONVOLUTION_ALPHA_BIAS_EXT
#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT                              0x8023
#endif //GL_POST_CONVOLUTION_ALPHA_BIAS_EXT

#endif //GL_EXT_convolution


typedef void (*PFNCONVOLUTIONFILTER1DEXTPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *image);

static inline void ConvolutionFilter1DEXT(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *image)
{
	static PFNCONVOLUTIONFILTER1DEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONFILTER1DEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionFilter1DEXT","GL_EXT_convolution"));
	 fn(target,internalformat,width,format,type,image);
}

typedef void (*PFNCONVOLUTIONFILTER2DEXTPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *image);

static inline void ConvolutionFilter2DEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *image)
{
	static PFNCONVOLUTIONFILTER2DEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONFILTER2DEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionFilter2DEXT","GL_EXT_convolution"));
	 fn(target,internalformat,width,height,format,type,image);
}

typedef void (*PFNCONVOLUTIONPARAMETERFEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat params);

static inline void ConvolutionParameterfEXT(GLenum target,GLenum pname,GLfloat params)
{
	static PFNCONVOLUTIONPARAMETERFEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERFEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionParameterfEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void ConvolutionParameterfvEXT(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNCONVOLUTIONPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionParameterfvEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERIEXTPROC_HPP)(GLenum target,GLenum pname,GLint params);

static inline void ConvolutionParameteriEXT(GLenum target,GLenum pname,GLint params)
{
	static PFNCONVOLUTIONPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionParameteriEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNCONVOLUTIONPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void ConvolutionParameterivEXT(GLenum target,GLenum pname,const GLint *params)
{
	static PFNCONVOLUTIONPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNCONVOLUTIONPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glConvolutionParameterivEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNCOPYCONVOLUTIONFILTER1DEXTPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);

static inline void CopyConvolutionFilter1DEXT(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCONVOLUTIONFILTER1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYCONVOLUTIONFILTER1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyConvolutionFilter1DEXT","GL_EXT_convolution"));
	 fn(target,internalformat,x,y,width);
}

typedef void (*PFNCOPYCONVOLUTIONFILTER2DEXTPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyConvolutionFilter2DEXT(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYCONVOLUTIONFILTER2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYCONVOLUTIONFILTER2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyConvolutionFilter2DEXT","GL_EXT_convolution"));
	 fn(target,internalformat,x,y,width,height);
}

typedef void (*PFNGETCONVOLUTIONFILTEREXTPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *image);

static inline void GetConvolutionFilterEXT(GLenum target,GLenum format,GLenum type,GLvoid *image)
{
	static PFNGETCONVOLUTIONFILTEREXTPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONFILTEREXTPROC_HPP>(_impl::_get_proc_address("glGetConvolutionFilterEXT","GL_EXT_convolution"));
	 fn(target,format,type,image);
}

typedef void (*PFNGETCONVOLUTIONPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetConvolutionParameterfvEXT(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETCONVOLUTIONPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetConvolutionParameterfvEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNGETCONVOLUTIONPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetConvolutionParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETCONVOLUTIONPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETCONVOLUTIONPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetConvolutionParameterivEXT","GL_EXT_convolution"));
	 fn(target,pname,params);
}

typedef void (*PFNGETSEPARABLEFILTEREXTPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *row,GLvoid *column,GLvoid *span);

static inline void GetSeparableFilterEXT(GLenum target,GLenum format,GLenum type,GLvoid *row,GLvoid *column,GLvoid *span)
{
	static PFNGETSEPARABLEFILTEREXTPROC_HPP fn=reinterpret_cast<PFNGETSEPARABLEFILTEREXTPROC_HPP>(_impl::_get_proc_address("glGetSeparableFilterEXT","GL_EXT_convolution"));
	 fn(target,format,type,row,column,span);
}

typedef void (*PFNSEPARABLEFILTER2DEXTPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *row,const GLvoid *column);

static inline void SeparableFilter2DEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *row,const GLvoid *column)
{
	static PFNSEPARABLEFILTER2DEXTPROC_HPP fn=reinterpret_cast<PFNSEPARABLEFILTER2DEXTPROC_HPP>(_impl::_get_proc_address("glSeparableFilter2DEXT","GL_EXT_convolution"));
	 fn(target,internalformat,width,height,format,type,row,column);
}
#ifndef GL_EXT_coordinate_frame

#define GL_EXT_coordinate_frame

#endif //GL_EXT_coordinate_frame


typedef void (*PFNTANGENT3BEXTPROC_HPP)(GLbyte tx,GLbyte ty,GLbyte tz);

static inline void Tangent3bEXT(GLbyte tx,GLbyte ty,GLbyte tz)
{
	static PFNTANGENT3BEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3BEXTPROC_HPP>(_impl::_get_proc_address("glTangent3bEXT","GL_EXT_coordinate_frame"));
	 fn(tx,ty,tz);
}

typedef void (*PFNTANGENT3BVEXTPROC_HPP)(const GLbyte *v);

static inline void Tangent3bvEXT(const GLbyte *v)
{
	static PFNTANGENT3BVEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3BVEXTPROC_HPP>(_impl::_get_proc_address("glTangent3bvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNTANGENT3DEXTPROC_HPP)(GLdouble tx,GLdouble ty,GLdouble tz);

static inline void Tangent3dEXT(GLdouble tx,GLdouble ty,GLdouble tz)
{
	static PFNTANGENT3DEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3DEXTPROC_HPP>(_impl::_get_proc_address("glTangent3dEXT","GL_EXT_coordinate_frame"));
	 fn(tx,ty,tz);
}

typedef void (*PFNTANGENT3DVEXTPROC_HPP)(const GLdouble *v);

static inline void Tangent3dvEXT(const GLdouble *v)
{
	static PFNTANGENT3DVEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3DVEXTPROC_HPP>(_impl::_get_proc_address("glTangent3dvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNTANGENT3FEXTPROC_HPP)(GLfloat tx,GLfloat ty,GLfloat tz);

static inline void Tangent3fEXT(GLfloat tx,GLfloat ty,GLfloat tz)
{
	static PFNTANGENT3FEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3FEXTPROC_HPP>(_impl::_get_proc_address("glTangent3fEXT","GL_EXT_coordinate_frame"));
	 fn(tx,ty,tz);
}

typedef void (*PFNTANGENT3FVEXTPROC_HPP)(const GLfloat *v);

static inline void Tangent3fvEXT(const GLfloat *v)
{
	static PFNTANGENT3FVEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3FVEXTPROC_HPP>(_impl::_get_proc_address("glTangent3fvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNTANGENT3IEXTPROC_HPP)(GLint tx,GLint ty,GLint tz);

static inline void Tangent3iEXT(GLint tx,GLint ty,GLint tz)
{
	static PFNTANGENT3IEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3IEXTPROC_HPP>(_impl::_get_proc_address("glTangent3iEXT","GL_EXT_coordinate_frame"));
	 fn(tx,ty,tz);
}

typedef void (*PFNTANGENT3IVEXTPROC_HPP)(const GLint *v);

static inline void Tangent3ivEXT(const GLint *v)
{
	static PFNTANGENT3IVEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3IVEXTPROC_HPP>(_impl::_get_proc_address("glTangent3ivEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNTANGENT3SEXTPROC_HPP)(GLshort tx,GLshort ty,GLshort tz);

static inline void Tangent3sEXT(GLshort tx,GLshort ty,GLshort tz)
{
	static PFNTANGENT3SEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3SEXTPROC_HPP>(_impl::_get_proc_address("glTangent3sEXT","GL_EXT_coordinate_frame"));
	 fn(tx,ty,tz);
}

typedef void (*PFNTANGENT3SVEXTPROC_HPP)(const GLshort *v);

static inline void Tangent3svEXT(const GLshort *v)
{
	static PFNTANGENT3SVEXTPROC_HPP fn=reinterpret_cast<PFNTANGENT3SVEXTPROC_HPP>(_impl::_get_proc_address("glTangent3svEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNBINORMAL3BEXTPROC_HPP)(GLbyte bx,GLbyte by,GLbyte bz);

static inline void Binormal3bEXT(GLbyte bx,GLbyte by,GLbyte bz)
{
	static PFNBINORMAL3BEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3BEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3bEXT","GL_EXT_coordinate_frame"));
	 fn(bx,by,bz);
}

typedef void (*PFNBINORMAL3BVEXTPROC_HPP)(const GLbyte *v);

static inline void Binormal3bvEXT(const GLbyte *v)
{
	static PFNBINORMAL3BVEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3BVEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3bvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNBINORMAL3DEXTPROC_HPP)(GLdouble bx,GLdouble by,GLdouble bz);

static inline void Binormal3dEXT(GLdouble bx,GLdouble by,GLdouble bz)
{
	static PFNBINORMAL3DEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3DEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3dEXT","GL_EXT_coordinate_frame"));
	 fn(bx,by,bz);
}

typedef void (*PFNBINORMAL3DVEXTPROC_HPP)(const GLdouble *v);

static inline void Binormal3dvEXT(const GLdouble *v)
{
	static PFNBINORMAL3DVEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3DVEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3dvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNBINORMAL3FEXTPROC_HPP)(GLfloat bx,GLfloat by,GLfloat bz);

static inline void Binormal3fEXT(GLfloat bx,GLfloat by,GLfloat bz)
{
	static PFNBINORMAL3FEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3FEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3fEXT","GL_EXT_coordinate_frame"));
	 fn(bx,by,bz);
}

typedef void (*PFNBINORMAL3FVEXTPROC_HPP)(const GLfloat *v);

static inline void Binormal3fvEXT(const GLfloat *v)
{
	static PFNBINORMAL3FVEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3FVEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3fvEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNBINORMAL3IEXTPROC_HPP)(GLint bx,GLint by,GLint bz);

static inline void Binormal3iEXT(GLint bx,GLint by,GLint bz)
{
	static PFNBINORMAL3IEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3IEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3iEXT","GL_EXT_coordinate_frame"));
	 fn(bx,by,bz);
}

typedef void (*PFNBINORMAL3IVEXTPROC_HPP)(const GLint *v);

static inline void Binormal3ivEXT(const GLint *v)
{
	static PFNBINORMAL3IVEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3IVEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3ivEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNBINORMAL3SEXTPROC_HPP)(GLshort bx,GLshort by,GLshort bz);

static inline void Binormal3sEXT(GLshort bx,GLshort by,GLshort bz)
{
	static PFNBINORMAL3SEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3SEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3sEXT","GL_EXT_coordinate_frame"));
	 fn(bx,by,bz);
}

typedef void (*PFNBINORMAL3SVEXTPROC_HPP)(const GLshort *v);

static inline void Binormal3svEXT(const GLshort *v)
{
	static PFNBINORMAL3SVEXTPROC_HPP fn=reinterpret_cast<PFNBINORMAL3SVEXTPROC_HPP>(_impl::_get_proc_address("glBinormal3svEXT","GL_EXT_coordinate_frame"));
	 fn(v);
}

typedef void (*PFNTANGENTPOINTEREXTPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void TangentPointerEXT(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNTANGENTPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNTANGENTPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glTangentPointerEXT","GL_EXT_coordinate_frame"));
	 fn(type,stride,pointer);
}

typedef void (*PFNBINORMALPOINTEREXTPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void BinormalPointerEXT(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNBINORMALPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNBINORMALPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glBinormalPointerEXT","GL_EXT_coordinate_frame"));
	 fn(type,stride,pointer);
}
#ifndef GL_EXT_copy_texture

#define GL_EXT_copy_texture

#endif //GL_EXT_copy_texture


typedef void (*PFNCOPYTEXIMAGE1DEXTPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);

static inline void CopyTexImage1DEXT(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border)
{
	static PFNCOPYTEXIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTexImage1DEXT","GL_EXT_copy_texture"));
	 fn(target,level,internalformat,x,y,width,border);
}

typedef void (*PFNCOPYTEXIMAGE2DEXTPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);

static inline void CopyTexImage2DEXT(GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)
{
	static PFNCOPYTEXIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTexImage2DEXT","GL_EXT_copy_texture"));
	 fn(target,level,internalformat,x,y,width,height,border);
}

typedef void (*PFNCOPYTEXSUBIMAGE1DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);

static inline void CopyTexSubImage1DEXT(GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYTEXSUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXSUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTexSubImage1DEXT","GL_EXT_copy_texture"));
	 fn(target,level,xoffset,x,y,width);
}

typedef void (*PFNCOPYTEXSUBIMAGE2DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyTexSubImage2DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYTEXSUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXSUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTexSubImage2DEXT","GL_EXT_copy_texture"));
	 fn(target,level,xoffset,yoffset,x,y,width,height);
}

typedef void (*PFNCOPYTEXSUBIMAGE3DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyTexSubImage3DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYTEXSUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXSUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTexSubImage3DEXT","GL_EXT_copy_texture"));
	 fn(target,level,xoffset,yoffset,zoffset,x,y,width,height);
}
#ifndef GL_EXT_cull_vertex

#define GL_EXT_cull_vertex
#ifndef GL_CULL_VERTEX_EXT
#define GL_CULL_VERTEX_EXT                                              0x81AA
#endif //GL_CULL_VERTEX_EXT
#ifndef GL_CULL_VERTEX_EYE_POSITION_EXT
#define GL_CULL_VERTEX_EYE_POSITION_EXT                                 0x81AB
#endif //GL_CULL_VERTEX_EYE_POSITION_EXT
#ifndef GL_CULL_VERTEX_OBJECT_POSITION_EXT
#define GL_CULL_VERTEX_OBJECT_POSITION_EXT                              0x81AC
#endif //GL_CULL_VERTEX_OBJECT_POSITION_EXT

#endif //GL_EXT_cull_vertex


typedef void (*PFNCULLPARAMETERDVEXTPROC_HPP)(GLenum pname,GLdouble *params);

static inline void CullParameterdvEXT(GLenum pname,GLdouble *params)
{
	static PFNCULLPARAMETERDVEXTPROC_HPP fn=reinterpret_cast<PFNCULLPARAMETERDVEXTPROC_HPP>(_impl::_get_proc_address("glCullParameterdvEXT","GL_EXT_cull_vertex"));
	 fn(pname,params);
}

typedef void (*PFNCULLPARAMETERFVEXTPROC_HPP)(GLenum pname,GLfloat *params);

static inline void CullParameterfvEXT(GLenum pname,GLfloat *params)
{
	static PFNCULLPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNCULLPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glCullParameterfvEXT","GL_EXT_cull_vertex"));
	 fn(pname,params);
}
#ifndef GL_EXT_debug_label

#define GL_EXT_debug_label
#ifndef GL_PROGRAM_PIPELINE_OBJECT_EXT
#define GL_PROGRAM_PIPELINE_OBJECT_EXT                                  0x8A4F
#endif //GL_PROGRAM_PIPELINE_OBJECT_EXT
#ifndef GL_PROGRAM_OBJECT_EXT
#define GL_PROGRAM_OBJECT_EXT                                           0x8B40
#endif //GL_PROGRAM_OBJECT_EXT
#ifndef GL_SHADER_OBJECT_EXT
#define GL_SHADER_OBJECT_EXT                                            0x8B48
#endif //GL_SHADER_OBJECT_EXT
#ifndef GL_BUFFER_OBJECT_EXT
#define GL_BUFFER_OBJECT_EXT                                            0x9151
#endif //GL_BUFFER_OBJECT_EXT
#ifndef GL_QUERY_OBJECT_EXT
#define GL_QUERY_OBJECT_EXT                                             0x9153
#endif //GL_QUERY_OBJECT_EXT
#ifndef GL_VERTEX_ARRAY_OBJECT_EXT
#define GL_VERTEX_ARRAY_OBJECT_EXT                                      0x9154
#endif //GL_VERTEX_ARRAY_OBJECT_EXT

#endif //GL_EXT_debug_label

#ifndef GL_EXT_depth_bounds_test

#define GL_EXT_depth_bounds_test
#ifndef GL_DEPTH_BOUNDS_TEST_EXT
#define GL_DEPTH_BOUNDS_TEST_EXT                                        0x8890
#endif //GL_DEPTH_BOUNDS_TEST_EXT
#ifndef GL_DEPTH_BOUNDS_EXT
#define GL_DEPTH_BOUNDS_EXT                                             0x8891
#endif //GL_DEPTH_BOUNDS_EXT

#endif //GL_EXT_depth_bounds_test


typedef void (*PFNDEPTHBOUNDSEXTPROC_HPP)(GLclampd zmin,GLclampd zmax);

static inline void DepthBoundsEXT(GLclampd zmin,GLclampd zmax)
{
	static PFNDEPTHBOUNDSEXTPROC_HPP fn=reinterpret_cast<PFNDEPTHBOUNDSEXTPROC_HPP>(_impl::_get_proc_address("glDepthBoundsEXT","GL_EXT_depth_bounds_test"));
	 fn(zmin,zmax);
}
#ifndef GL_EXT_direct_state_access

#define GL_EXT_direct_state_access
#ifndef GL_PROGRAM_MATRIX_EXT
#define GL_PROGRAM_MATRIX_EXT                                           0x8E2D
#endif //GL_PROGRAM_MATRIX_EXT
#ifndef GL_TRANSPOSE_PROGRAM_MATRIX_EXT
#define GL_TRANSPOSE_PROGRAM_MATRIX_EXT                                 0x8E2E
#endif //GL_TRANSPOSE_PROGRAM_MATRIX_EXT
#ifndef GL_PROGRAM_MATRIX_STACK_DEPTH_EXT
#define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT                               0x8E2F
#endif //GL_PROGRAM_MATRIX_STACK_DEPTH_EXT

#endif //GL_EXT_direct_state_access


typedef void (*PFNCLIENTATTRIBDEFAULTEXTPROC_HPP)(GLbitfield mask);

static inline void ClientAttribDefaultEXT(GLbitfield mask)
{
	static PFNCLIENTATTRIBDEFAULTEXTPROC_HPP fn=reinterpret_cast<PFNCLIENTATTRIBDEFAULTEXTPROC_HPP>(_impl::_get_proc_address("glClientAttribDefaultEXT","GL_EXT_direct_state_access"));
	 fn(mask);
}

typedef void (*PFNPUSHCLIENTATTRIBDEFAULTEXTPROC_HPP)(GLbitfield mask);

static inline void PushClientAttribDefaultEXT(GLbitfield mask)
{
	static PFNPUSHCLIENTATTRIBDEFAULTEXTPROC_HPP fn=reinterpret_cast<PFNPUSHCLIENTATTRIBDEFAULTEXTPROC_HPP>(_impl::_get_proc_address("glPushClientAttribDefaultEXT","GL_EXT_direct_state_access"));
	 fn(mask);
}

typedef void (*PFNMATRIXLOADFEXTPROC_HPP)(GLenum mode,const GLfloat *m);

static inline void MatrixLoadfEXT(GLenum mode,const GLfloat *m)
{
	static PFNMATRIXLOADFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXLOADFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixLoadfEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXLOADDEXTPROC_HPP)(GLenum mode,const GLdouble *m);

static inline void MatrixLoaddEXT(GLenum mode,const GLdouble *m)
{
	static PFNMATRIXLOADDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXLOADDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixLoaddEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXMULTFEXTPROC_HPP)(GLenum mode,const GLfloat *m);

static inline void MatrixMultfEXT(GLenum mode,const GLfloat *m)
{
	static PFNMATRIXMULTFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXMULTFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixMultfEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXMULTDEXTPROC_HPP)(GLenum mode,const GLdouble *m);

static inline void MatrixMultdEXT(GLenum mode,const GLdouble *m)
{
	static PFNMATRIXMULTDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXMULTDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixMultdEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXLOADIDENTITYEXTPROC_HPP)(GLenum mode);

static inline void MatrixLoadIdentityEXT(GLenum mode)
{
	static PFNMATRIXLOADIDENTITYEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXLOADIDENTITYEXTPROC_HPP>(_impl::_get_proc_address("glMatrixLoadIdentityEXT","GL_EXT_direct_state_access"));
	 fn(mode);
}

typedef void (*PFNMATRIXROTATEFEXTPROC_HPP)(GLenum mode,GLfloat angle,GLfloat x,GLfloat y,GLfloat z);

static inline void MatrixRotatefEXT(GLenum mode,GLfloat angle,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNMATRIXROTATEFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXROTATEFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixRotatefEXT","GL_EXT_direct_state_access"));
	 fn(mode,angle,x,y,z);
}

typedef void (*PFNMATRIXROTATEDEXTPROC_HPP)(GLenum mode,GLdouble angle,GLdouble x,GLdouble y,GLdouble z);

static inline void MatrixRotatedEXT(GLenum mode,GLdouble angle,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNMATRIXROTATEDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXROTATEDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixRotatedEXT","GL_EXT_direct_state_access"));
	 fn(mode,angle,x,y,z);
}

typedef void (*PFNMATRIXSCALEFEXTPROC_HPP)(GLenum mode,GLfloat x,GLfloat y,GLfloat z);

static inline void MatrixScalefEXT(GLenum mode,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNMATRIXSCALEFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXSCALEFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixScalefEXT","GL_EXT_direct_state_access"));
	 fn(mode,x,y,z);
}

typedef void (*PFNMATRIXSCALEDEXTPROC_HPP)(GLenum mode,GLdouble x,GLdouble y,GLdouble z);

static inline void MatrixScaledEXT(GLenum mode,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNMATRIXSCALEDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXSCALEDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixScaledEXT","GL_EXT_direct_state_access"));
	 fn(mode,x,y,z);
}

typedef void (*PFNMATRIXTRANSLATEFEXTPROC_HPP)(GLenum mode,GLfloat x,GLfloat y,GLfloat z);

static inline void MatrixTranslatefEXT(GLenum mode,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNMATRIXTRANSLATEFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXTRANSLATEFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixTranslatefEXT","GL_EXT_direct_state_access"));
	 fn(mode,x,y,z);
}

typedef void (*PFNMATRIXTRANSLATEDEXTPROC_HPP)(GLenum mode,GLdouble x,GLdouble y,GLdouble z);

static inline void MatrixTranslatedEXT(GLenum mode,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNMATRIXTRANSLATEDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXTRANSLATEDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixTranslatedEXT","GL_EXT_direct_state_access"));
	 fn(mode,x,y,z);
}

typedef void (*PFNMATRIXFRUSTUMEXTPROC_HPP)(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);

static inline void MatrixFrustumEXT(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)
{
	static PFNMATRIXFRUSTUMEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXFRUSTUMEXTPROC_HPP>(_impl::_get_proc_address("glMatrixFrustumEXT","GL_EXT_direct_state_access"));
	 fn(mode,left,right,bottom,top,zNear,zFar);
}

typedef void (*PFNMATRIXORTHOEXTPROC_HPP)(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar);

static inline void MatrixOrthoEXT(GLenum mode,GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,GLdouble zNear,GLdouble zFar)
{
	static PFNMATRIXORTHOEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXORTHOEXTPROC_HPP>(_impl::_get_proc_address("glMatrixOrthoEXT","GL_EXT_direct_state_access"));
	 fn(mode,left,right,bottom,top,zNear,zFar);
}

typedef void (*PFNMATRIXPOPEXTPROC_HPP)(GLenum mode);

static inline void MatrixPopEXT(GLenum mode)
{
	static PFNMATRIXPOPEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXPOPEXTPROC_HPP>(_impl::_get_proc_address("glMatrixPopEXT","GL_EXT_direct_state_access"));
	 fn(mode);
}

typedef void (*PFNMATRIXPUSHEXTPROC_HPP)(GLenum mode);

static inline void MatrixPushEXT(GLenum mode)
{
	static PFNMATRIXPUSHEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXPUSHEXTPROC_HPP>(_impl::_get_proc_address("glMatrixPushEXT","GL_EXT_direct_state_access"));
	 fn(mode);
}

typedef void (*PFNMATRIXLOADTRANSPOSEFEXTPROC_HPP)(GLenum mode,const GLfloat *m);

static inline void MatrixLoadTransposefEXT(GLenum mode,const GLfloat *m)
{
	static PFNMATRIXLOADTRANSPOSEFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXLOADTRANSPOSEFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixLoadTransposefEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXLOADTRANSPOSEDEXTPROC_HPP)(GLenum mode,const GLdouble *m);

static inline void MatrixLoadTransposedEXT(GLenum mode,const GLdouble *m)
{
	static PFNMATRIXLOADTRANSPOSEDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXLOADTRANSPOSEDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixLoadTransposedEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXMULTTRANSPOSEFEXTPROC_HPP)(GLenum mode,const GLfloat *m);

static inline void MatrixMultTransposefEXT(GLenum mode,const GLfloat *m)
{
	static PFNMATRIXMULTTRANSPOSEFEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXMULTTRANSPOSEFEXTPROC_HPP>(_impl::_get_proc_address("glMatrixMultTransposefEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNMATRIXMULTTRANSPOSEDEXTPROC_HPP)(GLenum mode,const GLdouble *m);

static inline void MatrixMultTransposedEXT(GLenum mode,const GLdouble *m)
{
	static PFNMATRIXMULTTRANSPOSEDEXTPROC_HPP fn=reinterpret_cast<PFNMATRIXMULTTRANSPOSEDEXTPROC_HPP>(_impl::_get_proc_address("glMatrixMultTransposedEXT","GL_EXT_direct_state_access"));
	 fn(mode,m);
}

typedef void (*PFNTEXTUREPARAMETERFEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLfloat param);

static inline void TextureParameterfEXT(GLuint texture,GLenum target,GLenum pname,GLfloat param)
{
	static PFNTEXTUREPARAMETERFEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERFEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameterfEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,param);
}

typedef void (*PFNTEXTUREPARAMETERFVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,const GLfloat *params);

static inline void TextureParameterfvEXT(GLuint texture,GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNTEXTUREPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNTEXTUREPARAMETERIEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLint param);

static inline void TextureParameteriEXT(GLuint texture,GLenum target,GLenum pname,GLint param)
{
	static PFNTEXTUREPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameteriEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,param);
}

typedef void (*PFNTEXTUREPARAMETERIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,const GLint *params);

static inline void TextureParameterivEXT(GLuint texture,GLenum target,GLenum pname,const GLint *params)
{
	static PFNTEXTUREPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNTEXTUREIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTUREIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glTextureImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,border,format,type,pixels);
}

typedef void (*PFNTEXTUREIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTUREIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glTextureImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,height,border,format,type,pixels);
}

typedef void (*PFNTEXTURESUBIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTURESUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glTextureSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,width,format,type,pixels);
}

typedef void (*PFNTEXTURESUBIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTURESUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glTextureSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,width,height,format,type,pixels);
}

typedef void (*PFNCOPYTEXTUREIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);

static inline void CopyTextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border)
{
	static PFNCOPYTEXTUREIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXTUREIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTextureImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,x,y,width,border);
}

typedef void (*PFNCOPYTEXTUREIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);

static inline void CopyTextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)
{
	static PFNCOPYTEXTUREIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXTUREIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTextureImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,x,y,width,height,border);
}

typedef void (*PFNCOPYTEXTURESUBIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);

static inline void CopyTextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYTEXTURESUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXTURESUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTextureSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,x,y,width);
}

typedef void (*PFNCOPYTEXTURESUBIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyTextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYTEXTURESUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXTURESUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTextureSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,x,y,width,height);
}

typedef void (*PFNGETTEXTUREIMAGEEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels);

static inline void GetTextureImageEXT(GLuint texture,GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels)
{
	static PFNGETTEXTUREIMAGEEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREIMAGEEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureImageEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,format,type,pixels);
}

typedef void (*PFNGETTEXTUREPARAMETERFVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLfloat *params);

static inline void GetTextureParameterfvEXT(GLuint texture,GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETTEXTUREPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNGETTEXTUREPARAMETERIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLint *params);

static inline void GetTextureParameterivEXT(GLuint texture,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETTEXTUREPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNGETTEXTURELEVELPARAMETERFVEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum pname,GLfloat *params);

static inline void GetTextureLevelParameterfvEXT(GLuint texture,GLenum target,GLint level,GLenum pname,GLfloat *params)
{
	static PFNGETTEXTURELEVELPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTURELEVELPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureLevelParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,pname,params);
}

typedef void (*PFNGETTEXTURELEVELPARAMETERIVEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum pname,GLint *params);

static inline void GetTextureLevelParameterivEXT(GLuint texture,GLenum target,GLint level,GLenum pname,GLint *params)
{
	static PFNGETTEXTURELEVELPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTURELEVELPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureLevelParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,pname,params);
}

typedef void (*PFNTEXTUREIMAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureImage3DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTUREIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glTextureImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,height,depth,border,format,type,pixels);
}

typedef void (*PFNTEXTURESUBIMAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXTURESUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURESUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glTextureSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
}

typedef void (*PFNCOPYTEXTURESUBIMAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyTextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYTEXTURESUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYTEXTURESUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCopyTextureSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,zoffset,x,y,width,height);
}

typedef void (*PFNMULTITEXPARAMETERFEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLfloat param);

static inline void MultiTexParameterfEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat param)
{
	static PFNMULTITEXPARAMETERFEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERFEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameterfEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,param);
}

typedef void (*PFNMULTITEXPARAMETERFVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLfloat *params);

static inline void MultiTexParameterfvEXT(GLenum texunit,GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNMULTITEXPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNMULTITEXPARAMETERIEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLint param);

static inline void MultiTexParameteriEXT(GLenum texunit,GLenum target,GLenum pname,GLint param)
{
	static PFNMULTITEXPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameteriEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,param);
}

typedef void (*PFNMULTITEXPARAMETERIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLint *params);

static inline void MultiTexParameterivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint *params)
{
	static PFNMULTITEXPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNMULTITEXIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,border,format,type,pixels);
}

typedef void (*PFNMULTITEXIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,height,border,format,type,pixels);
}

typedef void (*PFNMULTITEXSUBIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXSUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXSUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,width,format,type,pixels);
}

typedef void (*PFNMULTITEXSUBIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXSUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXSUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,width,height,format,type,pixels);
}

typedef void (*PFNCOPYMULTITEXIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border);

static inline void CopyMultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLint border)
{
	static PFNCOPYMULTITEXIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYMULTITEXIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyMultiTexImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,x,y,width,border);
}

typedef void (*PFNCOPYMULTITEXIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border);

static inline void CopyMultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLint x,GLint y,GLsizei width,GLsizei height,GLint border)
{
	static PFNCOPYMULTITEXIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYMULTITEXIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyMultiTexImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,x,y,width,height,border);
}

typedef void (*PFNCOPYMULTITEXSUBIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width);

static inline void CopyMultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYMULTITEXSUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYMULTITEXSUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCopyMultiTexSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,x,y,width);
}

typedef void (*PFNCOPYMULTITEXSUBIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyMultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYMULTITEXSUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYMULTITEXSUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCopyMultiTexSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,x,y,width,height);
}

typedef void (*PFNGETMULTITEXIMAGEEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels);

static inline void GetMultiTexImageEXT(GLenum texunit,GLenum target,GLint level,GLenum format,GLenum type,GLvoid *pixels)
{
	static PFNGETMULTITEXIMAGEEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXIMAGEEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexImageEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,format,type,pixels);
}

typedef void (*PFNGETMULTITEXPARAMETERFVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLfloat *params);

static inline void GetMultiTexParameterfvEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETMULTITEXPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXPARAMETERIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLint *params);

static inline void GetMultiTexParameterivEXT(GLenum texunit,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMULTITEXPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXLEVELPARAMETERFVEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum pname,GLfloat *params);

static inline void GetMultiTexLevelParameterfvEXT(GLenum texunit,GLenum target,GLint level,GLenum pname,GLfloat *params)
{
	static PFNGETMULTITEXLEVELPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXLEVELPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexLevelParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,pname,params);
}

typedef void (*PFNGETMULTITEXLEVELPARAMETERIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum pname,GLint *params);

static inline void GetMultiTexLevelParameterivEXT(GLenum texunit,GLenum target,GLint level,GLenum pname,GLint *params)
{
	static PFNGETMULTITEXLEVELPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXLEVELPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexLevelParameterivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,pname,params);
}

typedef void (*PFNMULTITEXIMAGE3DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexImage3DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,height,depth,border,format,type,pixels);
}

typedef void (*PFNMULTITEXSUBIMAGE3DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels);

static inline void MultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNMULTITEXSUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXSUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
}

typedef void (*PFNCOPYMULTITEXSUBIMAGE3DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height);

static inline void CopyMultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint x,GLint y,GLsizei width,GLsizei height)
{
	static PFNCOPYMULTITEXSUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOPYMULTITEXSUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCopyMultiTexSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,zoffset,x,y,width,height);
}

typedef void (*PFNBINDMULTITEXTUREEXTPROC_HPP)(GLenum texunit,GLenum target,GLuint texture);

static inline void BindMultiTextureEXT(GLenum texunit,GLenum target,GLuint texture)
{
	static PFNBINDMULTITEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNBINDMULTITEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glBindMultiTextureEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,texture);
}

typedef void (*PFNENABLECLIENTSTATEINDEXEDEXTPROC_HPP)(GLenum array,GLuint index);

static inline void EnableClientStateIndexedEXT(GLenum array,GLuint index)
{
	static PFNENABLECLIENTSTATEINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNENABLECLIENTSTATEINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glEnableClientStateIndexedEXT","GL_EXT_direct_state_access"));
	 fn(array,index);
}

typedef void (*PFNDISABLECLIENTSTATEINDEXEDEXTPROC_HPP)(GLenum array,GLuint index);

static inline void DisableClientStateIndexedEXT(GLenum array,GLuint index)
{
	static PFNDISABLECLIENTSTATEINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNDISABLECLIENTSTATEINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glDisableClientStateIndexedEXT","GL_EXT_direct_state_access"));
	 fn(array,index);
}

typedef void (*PFNENABLECLIENTSTATEIEXTPROC_HPP)(GLenum array,GLuint index);

static inline void EnableClientStateiEXT(GLenum array,GLuint index)
{
	static PFNENABLECLIENTSTATEIEXTPROC_HPP fn=reinterpret_cast<PFNENABLECLIENTSTATEIEXTPROC_HPP>(_impl::_get_proc_address("glEnableClientStateiEXT","GL_EXT_direct_state_access"));
	 fn(array,index);
}

typedef void (*PFNDISABLECLIENTSTATEIEXTPROC_HPP)(GLenum array,GLuint index);

static inline void DisableClientStateiEXT(GLenum array,GLuint index)
{
	static PFNDISABLECLIENTSTATEIEXTPROC_HPP fn=reinterpret_cast<PFNDISABLECLIENTSTATEIEXTPROC_HPP>(_impl::_get_proc_address("glDisableClientStateiEXT","GL_EXT_direct_state_access"));
	 fn(array,index);
}

typedef void (*PFNMULTITEXCOORDPOINTEREXTPROC_HPP)(GLenum texunit,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void MultiTexCoordPointerEXT(GLenum texunit,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNMULTITEXCOORDPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORDPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glMultiTexCoordPointerEXT","GL_EXT_direct_state_access"));
	 fn(texunit,size,type,stride,pointer);
}

typedef void (*PFNMULTITEXENVFEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLfloat param);

static inline void MultiTexEnvfEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat param)
{
	static PFNMULTITEXENVFEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXENVFEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexEnvfEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,param);
}

typedef void (*PFNMULTITEXENVFVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLfloat *params);

static inline void MultiTexEnvfvEXT(GLenum texunit,GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNMULTITEXENVFVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXENVFVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexEnvfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNMULTITEXENVIEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLint param);

static inline void MultiTexEnviEXT(GLenum texunit,GLenum target,GLenum pname,GLint param)
{
	static PFNMULTITEXENVIEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXENVIEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexEnviEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,param);
}

typedef void (*PFNMULTITEXENVIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLint *params);

static inline void MultiTexEnvivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint *params)
{
	static PFNMULTITEXENVIVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXENVIVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexEnvivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNMULTITEXGENDEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLdouble param);

static inline void MultiTexGendEXT(GLenum texunit,GLenum coord,GLenum pname,GLdouble param)
{
	static PFNMULTITEXGENDEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENDEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGendEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,param);
}

typedef void (*PFNMULTITEXGENDVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,const GLdouble *params);

static inline void MultiTexGendvEXT(GLenum texunit,GLenum coord,GLenum pname,const GLdouble *params)
{
	static PFNMULTITEXGENDVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENDVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGendvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNMULTITEXGENFEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLfloat param);

static inline void MultiTexGenfEXT(GLenum texunit,GLenum coord,GLenum pname,GLfloat param)
{
	static PFNMULTITEXGENFEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENFEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGenfEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,param);
}

typedef void (*PFNMULTITEXGENFVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,const GLfloat *params);

static inline void MultiTexGenfvEXT(GLenum texunit,GLenum coord,GLenum pname,const GLfloat *params)
{
	static PFNMULTITEXGENFVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENFVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGenfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNMULTITEXGENIEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLint param);

static inline void MultiTexGeniEXT(GLenum texunit,GLenum coord,GLenum pname,GLint param)
{
	static PFNMULTITEXGENIEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENIEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGeniEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,param);
}

typedef void (*PFNMULTITEXGENIVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,const GLint *params);

static inline void MultiTexGenivEXT(GLenum texunit,GLenum coord,GLenum pname,const GLint *params)
{
	static PFNMULTITEXGENIVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXGENIVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexGenivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNGETMULTITEXENVFVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLfloat *params);

static inline void GetMultiTexEnvfvEXT(GLenum texunit,GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETMULTITEXENVFVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXENVFVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexEnvfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXENVIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLint *params);

static inline void GetMultiTexEnvivEXT(GLenum texunit,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMULTITEXENVIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXENVIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexEnvivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXGENDVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLdouble *params);

static inline void GetMultiTexGendvEXT(GLenum texunit,GLenum coord,GLenum pname,GLdouble *params)
{
	static PFNGETMULTITEXGENDVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXGENDVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexGendvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNGETMULTITEXGENFVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLfloat *params);

static inline void GetMultiTexGenfvEXT(GLenum texunit,GLenum coord,GLenum pname,GLfloat *params)
{
	static PFNGETMULTITEXGENFVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXGENFVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexGenfvEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNGETMULTITEXGENIVEXTPROC_HPP)(GLenum texunit,GLenum coord,GLenum pname,GLint *params);

static inline void GetMultiTexGenivEXT(GLenum texunit,GLenum coord,GLenum pname,GLint *params)
{
	static PFNGETMULTITEXGENIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXGENIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexGenivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,coord,pname,params);
}

typedef void (*PFNGETFLOATINDEXEDVEXTPROC_HPP)(GLenum target,GLuint index,GLfloat *data);

static inline void GetFloatIndexedvEXT(GLenum target,GLuint index,GLfloat *data)
{
	static PFNGETFLOATINDEXEDVEXTPROC_HPP fn=reinterpret_cast<PFNGETFLOATINDEXEDVEXTPROC_HPP>(_impl::_get_proc_address("glGetFloatIndexedvEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNGETDOUBLEINDEXEDVEXTPROC_HPP)(GLenum target,GLuint index,GLdouble *data);

static inline void GetDoubleIndexedvEXT(GLenum target,GLuint index,GLdouble *data)
{
	static PFNGETDOUBLEINDEXEDVEXTPROC_HPP fn=reinterpret_cast<PFNGETDOUBLEINDEXEDVEXTPROC_HPP>(_impl::_get_proc_address("glGetDoubleIndexedvEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNGETPOINTERINDEXEDVEXTPROC_HPP)(GLenum target,GLuint index,GLvoid* *data);

static inline void GetPointerIndexedvEXT(GLenum target,GLuint index,GLvoid* *data)
{
	static PFNGETPOINTERINDEXEDVEXTPROC_HPP fn=reinterpret_cast<PFNGETPOINTERINDEXEDVEXTPROC_HPP>(_impl::_get_proc_address("glGetPointerIndexedvEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNGETFLOATI_VEXTPROC_HPP)(GLenum target,GLuint index,GLfloat *data);

static inline void GetFloati_vEXT(GLenum target,GLuint index,GLfloat *data)
{
	static PFNGETFLOATI_VEXTPROC_HPP fn=reinterpret_cast<PFNGETFLOATI_VEXTPROC_HPP>(_impl::_get_proc_address("glGetFloati_vEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNGETDOUBLEI_VEXTPROC_HPP)(GLenum target,GLuint index,GLdouble *data);

static inline void GetDoublei_vEXT(GLenum target,GLuint index,GLdouble *data)
{
	static PFNGETDOUBLEI_VEXTPROC_HPP fn=reinterpret_cast<PFNGETDOUBLEI_VEXTPROC_HPP>(_impl::_get_proc_address("glGetDoublei_vEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNGETPOINTERI_VEXTPROC_HPP)(GLenum target,GLuint index,GLvoid* *data);

static inline void GetPointeri_vEXT(GLenum target,GLuint index,GLvoid* *data)
{
	static PFNGETPOINTERI_VEXTPROC_HPP fn=reinterpret_cast<PFNGETPOINTERI_VEXTPROC_HPP>(_impl::_get_proc_address("glGetPointeri_vEXT","GL_EXT_direct_state_access"));
	 fn(target,index,data);
}

typedef void (*PFNCOMPRESSEDTEXTUREIMAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureImage3DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTUREIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTUREIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,height,depth,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDTEXTUREIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureImage2DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTUREIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTUREIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,height,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDTEXTUREIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureImage1DEXT(GLuint texture,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTUREIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTUREIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,internalformat,width,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureSubImage3DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureSubImage2DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,yoffset,width,height,format,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC_HPP)(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedTextureSubImage1DEXT(GLuint texture,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedTextureSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,level,xoffset,width,format,imageSize,bits);
}

typedef void (*PFNGETCOMPRESSEDTEXTUREIMAGEEXTPROC_HPP)(GLuint texture,GLenum target,GLint lod,GLvoid *img);

static inline void GetCompressedTextureImageEXT(GLuint texture,GLenum target,GLint lod,GLvoid *img)
{
	static PFNGETCOMPRESSEDTEXTUREIMAGEEXTPROC_HPP fn=reinterpret_cast<PFNGETCOMPRESSEDTEXTUREIMAGEEXTPROC_HPP>(_impl::_get_proc_address("glGetCompressedTextureImageEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,lod,img);
}

typedef void (*PFNCOMPRESSEDMULTITEXIMAGE3DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexImage3DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,height,depth,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDMULTITEXIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexImage2DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,height,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDMULTITEXIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexImage1DEXT(GLenum texunit,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,internalformat,width,border,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexSubImage3DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexSubImage3DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexSubImage2DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexSubImage2DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,yoffset,width,height,format,imageSize,bits);
}

typedef void (*PFNCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC_HPP)(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *bits);

static inline void CompressedMultiTexSubImage1DEXT(GLenum texunit,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const GLvoid *bits)
{
	static PFNCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glCompressedMultiTexSubImage1DEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,level,xoffset,width,format,imageSize,bits);
}

typedef void (*PFNGETCOMPRESSEDMULTITEXIMAGEEXTPROC_HPP)(GLenum texunit,GLenum target,GLint lod,GLvoid *img);

static inline void GetCompressedMultiTexImageEXT(GLenum texunit,GLenum target,GLint lod,GLvoid *img)
{
	static PFNGETCOMPRESSEDMULTITEXIMAGEEXTPROC_HPP fn=reinterpret_cast<PFNGETCOMPRESSEDMULTITEXIMAGEEXTPROC_HPP>(_impl::_get_proc_address("glGetCompressedMultiTexImageEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,lod,img);
}

typedef void (*PFNNAMEDPROGRAMSTRINGEXTPROC_HPP)(GLuint program,GLenum target,GLenum format,GLsizei len,const GLvoid *string);

static inline void NamedProgramStringEXT(GLuint program,GLenum target,GLenum format,GLsizei len,const GLvoid *string)
{
	static PFNNAMEDPROGRAMSTRINGEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMSTRINGEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramStringEXT","GL_EXT_direct_state_access"));
	 fn(program,target,format,len,string);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETER4DEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void NamedProgramLocalParameter4dEXT(GLuint program,GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNNAMEDPROGRAMLOCALPARAMETER4DEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETER4DEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameter4dEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,x,y,z,w);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,const GLdouble *params);

static inline void NamedProgramLocalParameter4dvEXT(GLuint program,GLenum target,GLuint index,const GLdouble *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameter4dvEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETER4FEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void NamedProgramLocalParameter4fEXT(GLuint program,GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNNAMEDPROGRAMLOCALPARAMETER4FEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETER4FEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameter4fEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,x,y,z,w);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,const GLfloat *params);

static inline void NamedProgramLocalParameter4fvEXT(GLuint program,GLenum target,GLuint index,const GLfloat *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameter4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLdouble *params);

static inline void GetNamedProgramLocalParameterdvEXT(GLuint program,GLenum target,GLuint index,GLdouble *params)
{
	static PFNGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramLocalParameterdvEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLfloat *params);

static inline void GetNamedProgramLocalParameterfvEXT(GLuint program,GLenum target,GLuint index,GLfloat *params)
{
	static PFNGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramLocalParameterfvEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNGETNAMEDPROGRAMIVEXTPROC_HPP)(GLuint program,GLenum target,GLenum pname,GLint *params);

static inline void GetNamedProgramivEXT(GLuint program,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETNAMEDPROGRAMIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,pname,params);
}

typedef void (*PFNGETNAMEDPROGRAMSTRINGEXTPROC_HPP)(GLuint program,GLenum target,GLenum pname,GLvoid *string);

static inline void GetNamedProgramStringEXT(GLuint program,GLenum target,GLenum pname,GLvoid *string)
{
	static PFNGETNAMEDPROGRAMSTRINGEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMSTRINGEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramStringEXT","GL_EXT_direct_state_access"));
	 fn(program,target,pname,string);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLsizei count,const GLfloat *params);

static inline void NamedProgramLocalParameters4fvEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLfloat *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameters4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,count,params);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);

static inline void NamedProgramLocalParameterI4iEXT(GLuint program,GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameterI4iEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,x,y,z,w);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,const GLint *params);

static inline void NamedProgramLocalParameterI4ivEXT(GLuint program,GLenum target,GLuint index,const GLint *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameterI4ivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLsizei count,const GLint *params);

static inline void NamedProgramLocalParametersI4ivEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLint *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParametersI4ivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,count,params);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);

static inline void NamedProgramLocalParameterI4uiEXT(GLuint program,GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameterI4uiEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,x,y,z,w);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,const GLuint *params);

static inline void NamedProgramLocalParameterI4uivEXT(GLuint program,GLenum target,GLuint index,const GLuint *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParameterI4uivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLsizei count,const GLuint *params);

static inline void NamedProgramLocalParametersI4uivEXT(GLuint program,GLenum target,GLuint index,GLsizei count,const GLuint *params)
{
	static PFNNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC_HPP>(_impl::_get_proc_address("glNamedProgramLocalParametersI4uivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,count,params);
}

typedef void (*PFNGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLint *params);

static inline void GetNamedProgramLocalParameterIivEXT(GLuint program,GLenum target,GLuint index,GLint *params)
{
	static PFNGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramLocalParameterIivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC_HPP)(GLuint program,GLenum target,GLuint index,GLuint *params);

static inline void GetNamedProgramLocalParameterIuivEXT(GLuint program,GLenum target,GLuint index,GLuint *params)
{
	static PFNGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedProgramLocalParameterIuivEXT","GL_EXT_direct_state_access"));
	 fn(program,target,index,params);
}

typedef void (*PFNTEXTUREPARAMETERIIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,const GLint *params);

static inline void TextureParameterIivEXT(GLuint texture,GLenum target,GLenum pname,const GLint *params)
{
	static PFNTEXTUREPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameterIivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNTEXTUREPARAMETERIUIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,const GLuint *params);

static inline void TextureParameterIuivEXT(GLuint texture,GLenum target,GLenum pname,const GLuint *params)
{
	static PFNTEXTUREPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glTextureParameterIuivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNGETTEXTUREPARAMETERIIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLint *params);

static inline void GetTextureParameterIivEXT(GLuint texture,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETTEXTUREPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureParameterIivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNGETTEXTUREPARAMETERIUIVEXTPROC_HPP)(GLuint texture,GLenum target,GLenum pname,GLuint *params);

static inline void GetTextureParameterIuivEXT(GLuint texture,GLenum target,GLenum pname,GLuint *params)
{
	static PFNGETTEXTUREPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTextureParameterIuivEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,pname,params);
}

typedef void (*PFNMULTITEXPARAMETERIIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLint *params);

static inline void MultiTexParameterIivEXT(GLenum texunit,GLenum target,GLenum pname,const GLint *params)
{
	static PFNMULTITEXPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameterIivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNMULTITEXPARAMETERIUIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,const GLuint *params);

static inline void MultiTexParameterIuivEXT(GLenum texunit,GLenum target,GLenum pname,const GLuint *params)
{
	static PFNMULTITEXPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glMultiTexParameterIuivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXPARAMETERIIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLint *params);

static inline void GetMultiTexParameterIivEXT(GLenum texunit,GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMULTITEXPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexParameterIivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNGETMULTITEXPARAMETERIUIVEXTPROC_HPP)(GLenum texunit,GLenum target,GLenum pname,GLuint *params);

static inline void GetMultiTexParameterIuivEXT(GLenum texunit,GLenum target,GLenum pname,GLuint *params)
{
	static PFNGETMULTITEXPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMULTITEXPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMultiTexParameterIuivEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,pname,params);
}

typedef void (*PFNPROGRAMUNIFORM1FEXTPROC_HPP)(GLuint program,GLint location,GLfloat v0);

static inline void ProgramUniform1fEXT(GLuint program,GLint location,GLfloat v0)
{
	static PFNPROGRAMUNIFORM1FEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1FEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1fEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM2FEXTPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1);

static inline void ProgramUniform2fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1)
{
	static PFNPROGRAMUNIFORM2FEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2FEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2fEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM3FEXTPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2);

static inline void ProgramUniform3fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2)
{
	static PFNPROGRAMUNIFORM3FEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3FEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3fEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM4FEXTPROC_HPP)(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3);

static inline void ProgramUniform4fEXT(GLuint program,GLint location,GLfloat v0,GLfloat v1,GLfloat v2,GLfloat v3)
{
	static PFNPROGRAMUNIFORM4FEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4FEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4fEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM1IEXTPROC_HPP)(GLuint program,GLint location,GLint v0);

static inline void ProgramUniform1iEXT(GLuint program,GLint location,GLint v0)
{
	static PFNPROGRAMUNIFORM1IEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1IEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1iEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM2IEXTPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1);

static inline void ProgramUniform2iEXT(GLuint program,GLint location,GLint v0,GLint v1)
{
	static PFNPROGRAMUNIFORM2IEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2IEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2iEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM3IEXTPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1,GLint v2);

static inline void ProgramUniform3iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2)
{
	static PFNPROGRAMUNIFORM3IEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3IEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3iEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM4IEXTPROC_HPP)(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3);

static inline void ProgramUniform4iEXT(GLuint program,GLint location,GLint v0,GLint v1,GLint v2,GLint v3)
{
	static PFNPROGRAMUNIFORM4IEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4IEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4iEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM1FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform1fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM1FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform2fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM2FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform3fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM3FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLfloat *value);

static inline void ProgramUniform4fvEXT(GLuint program,GLint location,GLsizei count,const GLfloat *value)
{
	static PFNPROGRAMUNIFORM4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM1IVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform1ivEXT(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM1IVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1IVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1ivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2IVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform2ivEXT(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM2IVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2IVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2ivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3IVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform3ivEXT(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM3IVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3IVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3ivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4IVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint *value);

static inline void ProgramUniform4ivEXT(GLuint program,GLint location,GLsizei count,const GLint *value)
{
	static PFNPROGRAMUNIFORM4IVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4IVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4ivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X3FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X3FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X3FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x3fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X2FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X2FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X2FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x2fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X4FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix2x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X2FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4x2fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X2FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X2FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x2fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X4FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix3x4fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x4fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X3FVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value);

static inline void ProgramUniformMatrix4x3fvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLfloat *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X3FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X3FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x3fvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORM1UIEXTPROC_HPP)(GLuint program,GLint location,GLuint v0);

static inline void ProgramUniform1uiEXT(GLuint program,GLint location,GLuint v0)
{
	static PFNPROGRAMUNIFORM1UIEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UIEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1uiEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0);
}

typedef void (*PFNPROGRAMUNIFORM2UIEXTPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1);

static inline void ProgramUniform2uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1)
{
	static PFNPROGRAMUNIFORM2UIEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UIEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2uiEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1);
}

typedef void (*PFNPROGRAMUNIFORM3UIEXTPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2);

static inline void ProgramUniform3uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2)
{
	static PFNPROGRAMUNIFORM3UIEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UIEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3uiEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2);
}

typedef void (*PFNPROGRAMUNIFORM4UIEXTPROC_HPP)(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);

static inline void ProgramUniform4uiEXT(GLuint program,GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)
{
	static PFNPROGRAMUNIFORM4UIEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UIEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4uiEXT","GL_EXT_direct_state_access"));
	 fn(program,location,v0,v1,v2,v3);
}

typedef void (*PFNPROGRAMUNIFORM1UIVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform1uivEXT(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM1UIVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UIVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1uivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2UIVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform2uivEXT(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM2UIVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UIVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2uivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3UIVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform3uivEXT(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM3UIVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UIVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3uivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4UIVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint *value);

static inline void ProgramUniform4uivEXT(GLuint program,GLint location,GLsizei count,const GLuint *value)
{
	static PFNPROGRAMUNIFORM4UIVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UIVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4uivEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNNAMEDBUFFERDATAEXTPROC_HPP)(GLuint buffer,GLsizeiptr size,const GLvoid *data,GLenum usage);

static inline void NamedBufferDataEXT(GLuint buffer,GLsizeiptr size,const GLvoid *data,GLenum usage)
{
	static PFNNAMEDBUFFERDATAEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDBUFFERDATAEXTPROC_HPP>(_impl::_get_proc_address("glNamedBufferDataEXT","GL_EXT_direct_state_access"));
	 fn(buffer,size,data,usage);
}

typedef void (*PFNNAMEDBUFFERSUBDATAEXTPROC_HPP)(GLuint buffer,GLintptr offset,GLsizeiptr size,const GLvoid *data);

static inline void NamedBufferSubDataEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,const GLvoid *data)
{
	static PFNNAMEDBUFFERSUBDATAEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDBUFFERSUBDATAEXTPROC_HPP>(_impl::_get_proc_address("glNamedBufferSubDataEXT","GL_EXT_direct_state_access"));
	 fn(buffer,offset,size,data);
}

typedef GLvoid* (*PFNMAPNAMEDBUFFEREXTPROC_HPP)(GLuint buffer,GLenum access);

static inline GLvoid* MapNamedBufferEXT(GLuint buffer,GLenum access)
{
	static PFNMAPNAMEDBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNMAPNAMEDBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glMapNamedBufferEXT","GL_EXT_direct_state_access"));
	return fn(buffer,access);
}

typedef GLboolean (*PFNUNMAPNAMEDBUFFEREXTPROC_HPP)(GLuint buffer);

static inline GLboolean UnmapNamedBufferEXT(GLuint buffer)
{
	static PFNUNMAPNAMEDBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNUNMAPNAMEDBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glUnmapNamedBufferEXT","GL_EXT_direct_state_access"));
	return fn(buffer);
}

typedef GLvoid* (*PFNMAPNAMEDBUFFERRANGEEXTPROC_HPP)(GLuint buffer,GLintptr offset,GLsizeiptr length,GLbitfield access);

static inline GLvoid* MapNamedBufferRangeEXT(GLuint buffer,GLintptr offset,GLsizeiptr length,GLbitfield access)
{
	static PFNMAPNAMEDBUFFERRANGEEXTPROC_HPP fn=reinterpret_cast<PFNMAPNAMEDBUFFERRANGEEXTPROC_HPP>(_impl::_get_proc_address("glMapNamedBufferRangeEXT","GL_EXT_direct_state_access"));
	return fn(buffer,offset,length,access);
}

typedef void (*PFNFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC_HPP)(GLuint buffer,GLintptr offset,GLsizeiptr length);

static inline void FlushMappedNamedBufferRangeEXT(GLuint buffer,GLintptr offset,GLsizeiptr length)
{
	static PFNFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC_HPP fn=reinterpret_cast<PFNFLUSHMAPPEDNAMEDBUFFERRANGEEXTPROC_HPP>(_impl::_get_proc_address("glFlushMappedNamedBufferRangeEXT","GL_EXT_direct_state_access"));
	 fn(buffer,offset,length);
}

typedef void (*PFNNAMEDCOPYBUFFERSUBDATAEXTPROC_HPP)(GLuint readBuffer,GLuint writeBuffer,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size);

static inline void NamedCopyBufferSubDataEXT(GLuint readBuffer,GLuint writeBuffer,GLintptr readOffset,GLintptr writeOffset,GLsizeiptr size)
{
	static PFNNAMEDCOPYBUFFERSUBDATAEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDCOPYBUFFERSUBDATAEXTPROC_HPP>(_impl::_get_proc_address("glNamedCopyBufferSubDataEXT","GL_EXT_direct_state_access"));
	 fn(readBuffer,writeBuffer,readOffset,writeOffset,size);
}

typedef void (*PFNGETNAMEDBUFFERPARAMETERIVEXTPROC_HPP)(GLuint buffer,GLenum pname,GLint *params);

static inline void GetNamedBufferParameterivEXT(GLuint buffer,GLenum pname,GLint *params)
{
	static PFNGETNAMEDBUFFERPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDBUFFERPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedBufferParameterivEXT","GL_EXT_direct_state_access"));
	 fn(buffer,pname,params);
}

typedef void (*PFNGETNAMEDBUFFERPOINTERVEXTPROC_HPP)(GLuint buffer,GLenum pname,GLvoid* *params);

static inline void GetNamedBufferPointervEXT(GLuint buffer,GLenum pname,GLvoid* *params)
{
	static PFNGETNAMEDBUFFERPOINTERVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDBUFFERPOINTERVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedBufferPointervEXT","GL_EXT_direct_state_access"));
	 fn(buffer,pname,params);
}

typedef void (*PFNGETNAMEDBUFFERSUBDATAEXTPROC_HPP)(GLuint buffer,GLintptr offset,GLsizeiptr size,GLvoid *data);

static inline void GetNamedBufferSubDataEXT(GLuint buffer,GLintptr offset,GLsizeiptr size,GLvoid *data)
{
	static PFNGETNAMEDBUFFERSUBDATAEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDBUFFERSUBDATAEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedBufferSubDataEXT","GL_EXT_direct_state_access"));
	 fn(buffer,offset,size,data);
}

typedef void (*PFNTEXTUREBUFFEREXTPROC_HPP)(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer);

static inline void TextureBufferEXT(GLuint texture,GLenum target,GLenum internalformat,GLuint buffer)
{
	static PFNTEXTUREBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glTextureBufferEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,internalformat,buffer);
}

typedef void (*PFNMULTITEXBUFFEREXTPROC_HPP)(GLenum texunit,GLenum target,GLenum internalformat,GLuint buffer);

static inline void MultiTexBufferEXT(GLenum texunit,GLenum target,GLenum internalformat,GLuint buffer)
{
	static PFNMULTITEXBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glMultiTexBufferEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,internalformat,buffer);
}

typedef void (*PFNNAMEDRENDERBUFFERSTORAGEEXTPROC_HPP)(GLuint renderbuffer,GLenum internalformat,GLsizei width,GLsizei height);

static inline void NamedRenderbufferStorageEXT(GLuint renderbuffer,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNNAMEDRENDERBUFFERSTORAGEEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDRENDERBUFFERSTORAGEEXTPROC_HPP>(_impl::_get_proc_address("glNamedRenderbufferStorageEXT","GL_EXT_direct_state_access"));
	 fn(renderbuffer,internalformat,width,height);
}

typedef void (*PFNGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC_HPP)(GLuint renderbuffer,GLenum pname,GLint *params);

static inline void GetNamedRenderbufferParameterivEXT(GLuint renderbuffer,GLenum pname,GLint *params)
{
	static PFNGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedRenderbufferParameterivEXT","GL_EXT_direct_state_access"));
	 fn(renderbuffer,pname,params);
}

typedef GLenum (*PFNCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC_HPP)(GLuint framebuffer,GLenum target);

static inline GLenum CheckNamedFramebufferStatusEXT(GLuint framebuffer,GLenum target)
{
	static PFNCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC_HPP fn=reinterpret_cast<PFNCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC_HPP>(_impl::_get_proc_address("glCheckNamedFramebufferStatusEXT","GL_EXT_direct_state_access"));
	return fn(framebuffer,target);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTURE1DEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void NamedFramebufferTexture1DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNNAMEDFRAMEBUFFERTEXTURE1DEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTURE1DEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTexture1DEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,textarget,texture,level);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTURE2DEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void NamedFramebufferTexture2DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNNAMEDFRAMEBUFFERTEXTURE2DEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTURE2DEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTexture2DEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,textarget,texture,level);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTURE3DEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);

static inline void NamedFramebufferTexture3DEXT(GLuint framebuffer,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)
{
	static PFNNAMEDFRAMEBUFFERTEXTURE3DEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTURE3DEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTexture3DEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,textarget,texture,level,zoffset);
}

typedef void (*PFNNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);

static inline void NamedFramebufferRenderbufferEXT(GLuint framebuffer,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)
{
	static PFNNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferRenderbufferEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,renderbuffertarget,renderbuffer);
}

typedef void (*PFNGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLenum pname,GLint *params);

static inline void GetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer,GLenum attachment,GLenum pname,GLint *params)
{
	static PFNGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetNamedFramebufferAttachmentParameterivEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,pname,params);
}

typedef void (*PFNGENERATETEXTUREMIPMAPEXTPROC_HPP)(GLuint texture,GLenum target);

static inline void GenerateTextureMipmapEXT(GLuint texture,GLenum target)
{
	static PFNGENERATETEXTUREMIPMAPEXTPROC_HPP fn=reinterpret_cast<PFNGENERATETEXTUREMIPMAPEXTPROC_HPP>(_impl::_get_proc_address("glGenerateTextureMipmapEXT","GL_EXT_direct_state_access"));
	 fn(texture,target);
}

typedef void (*PFNGENERATEMULTITEXMIPMAPEXTPROC_HPP)(GLenum texunit,GLenum target);

static inline void GenerateMultiTexMipmapEXT(GLenum texunit,GLenum target)
{
	static PFNGENERATEMULTITEXMIPMAPEXTPROC_HPP fn=reinterpret_cast<PFNGENERATEMULTITEXMIPMAPEXTPROC_HPP>(_impl::_get_proc_address("glGenerateMultiTexMipmapEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target);
}

typedef void (*PFNFRAMEBUFFERDRAWBUFFEREXTPROC_HPP)(GLuint framebuffer,GLenum mode);

static inline void FramebufferDrawBufferEXT(GLuint framebuffer,GLenum mode)
{
	static PFNFRAMEBUFFERDRAWBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERDRAWBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glFramebufferDrawBufferEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,mode);
}

typedef void (*PFNFRAMEBUFFERDRAWBUFFERSEXTPROC_HPP)(GLuint framebuffer,GLsizei n,const GLenum *bufs);

static inline void FramebufferDrawBuffersEXT(GLuint framebuffer,GLsizei n,const GLenum *bufs)
{
	static PFNFRAMEBUFFERDRAWBUFFERSEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERDRAWBUFFERSEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferDrawBuffersEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,n,bufs);
}

typedef void (*PFNFRAMEBUFFERREADBUFFEREXTPROC_HPP)(GLuint framebuffer,GLenum mode);

static inline void FramebufferReadBufferEXT(GLuint framebuffer,GLenum mode)
{
	static PFNFRAMEBUFFERREADBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERREADBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glFramebufferReadBufferEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,mode);
}

typedef void (*PFNGETFRAMEBUFFERPARAMETERIVEXTPROC_HPP)(GLuint framebuffer,GLenum pname,GLint *params);

static inline void GetFramebufferParameterivEXT(GLuint framebuffer,GLenum pname,GLint *params)
{
	static PFNGETFRAMEBUFFERPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETFRAMEBUFFERPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetFramebufferParameterivEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,pname,params);
}

typedef void (*PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP)(GLuint renderbuffer,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);

static inline void NamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP>(_impl::_get_proc_address("glNamedRenderbufferStorageMultisampleEXT","GL_EXT_direct_state_access"));
	 fn(renderbuffer,samples,internalformat,width,height);
}

typedef void (*PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC_HPP)(GLuint renderbuffer,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height);

static inline void NamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC_HPP>(_impl::_get_proc_address("glNamedRenderbufferStorageMultisampleCoverageEXT","GL_EXT_direct_state_access"));
	 fn(renderbuffer,coverageSamples,colorSamples,internalformat,width,height);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTUREEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level);

static inline void NamedFramebufferTextureEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level)
{
	static PFNNAMEDFRAMEBUFFERTEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTextureEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,texture,level);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLint layer);

static inline void NamedFramebufferTextureLayerEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLint layer)
{
	static PFNNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTextureLayerEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,texture,level,layer);
}

typedef void (*PFNNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC_HPP)(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLenum face);

static inline void NamedFramebufferTextureFaceEXT(GLuint framebuffer,GLenum attachment,GLuint texture,GLint level,GLenum face)
{
	static PFNNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC_HPP fn=reinterpret_cast<PFNNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC_HPP>(_impl::_get_proc_address("glNamedFramebufferTextureFaceEXT","GL_EXT_direct_state_access"));
	 fn(framebuffer,attachment,texture,level,face);
}

typedef void (*PFNTEXTURERENDERBUFFEREXTPROC_HPP)(GLuint texture,GLenum target,GLuint renderbuffer);

static inline void TextureRenderbufferEXT(GLuint texture,GLenum target,GLuint renderbuffer)
{
	static PFNTEXTURERENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNTEXTURERENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glTextureRenderbufferEXT","GL_EXT_direct_state_access"));
	 fn(texture,target,renderbuffer);
}

typedef void (*PFNMULTITEXRENDERBUFFEREXTPROC_HPP)(GLenum texunit,GLenum target,GLuint renderbuffer);

static inline void MultiTexRenderbufferEXT(GLenum texunit,GLenum target,GLuint renderbuffer)
{
	static PFNMULTITEXRENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNMULTITEXRENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glMultiTexRenderbufferEXT","GL_EXT_direct_state_access"));
	 fn(texunit,target,renderbuffer);
}

typedef void (*PFNPROGRAMUNIFORM1DEXTPROC_HPP)(GLuint program,GLint location,GLdouble x);

static inline void ProgramUniform1dEXT(GLuint program,GLint location,GLdouble x)
{
	static PFNPROGRAMUNIFORM1DEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1DEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1dEXT","GL_EXT_direct_state_access"));
	 fn(program,location,x);
}

typedef void (*PFNPROGRAMUNIFORM2DEXTPROC_HPP)(GLuint program,GLint location,GLdouble x,GLdouble y);

static inline void ProgramUniform2dEXT(GLuint program,GLint location,GLdouble x,GLdouble y)
{
	static PFNPROGRAMUNIFORM2DEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2DEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2dEXT","GL_EXT_direct_state_access"));
	 fn(program,location,x,y);
}

typedef void (*PFNPROGRAMUNIFORM3DEXTPROC_HPP)(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z);

static inline void ProgramUniform3dEXT(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNPROGRAMUNIFORM3DEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3DEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3dEXT","GL_EXT_direct_state_access"));
	 fn(program,location,x,y,z);
}

typedef void (*PFNPROGRAMUNIFORM4DEXTPROC_HPP)(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void ProgramUniform4dEXT(GLuint program,GLint location,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNPROGRAMUNIFORM4DEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4DEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4dEXT","GL_EXT_direct_state_access"));
	 fn(program,location,x,y,z,w);
}

typedef void (*PFNPROGRAMUNIFORM1DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform1dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM1DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform1dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform2dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM2DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform2dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform3dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM3DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform3dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLdouble *value);

static inline void ProgramUniform4dvEXT(GLuint program,GLint location,GLsizei count,const GLdouble *value)
{
	static PFNPROGRAMUNIFORM4DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniform4dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X3DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2x3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X3DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X3DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x3dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX2X4DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix2x4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX2X4DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX2X4DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix2x4dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X2DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3x2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X2DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X2DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x2dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX3X4DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix3x4dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX3X4DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX3X4DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix3x4dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X2DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4x2dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X2DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X2DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x2dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNPROGRAMUNIFORMMATRIX4X3DVEXTPROC_HPP)(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value);

static inline void ProgramUniformMatrix4x3dvEXT(GLuint program,GLint location,GLsizei count,GLboolean transpose,const GLdouble *value)
{
	static PFNPROGRAMUNIFORMMATRIX4X3DVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMMATRIX4X3DVEXTPROC_HPP>(_impl::_get_proc_address("glProgramUniformMatrix4x3dvEXT","GL_EXT_direct_state_access"));
	 fn(program,location,count,transpose,value);
}

typedef void (*PFNENABLEVERTEXARRAYATTRIBEXTPROC_HPP)(GLuint vaobj,GLuint index);

static inline void EnableVertexArrayAttribEXT(GLuint vaobj,GLuint index)
{
	static PFNENABLEVERTEXARRAYATTRIBEXTPROC_HPP fn=reinterpret_cast<PFNENABLEVERTEXARRAYATTRIBEXTPROC_HPP>(_impl::_get_proc_address("glEnableVertexArrayAttribEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,index);
}

typedef void (*PFNDISABLEVERTEXARRAYATTRIBEXTPROC_HPP)(GLuint vaobj,GLuint index);

static inline void DisableVertexArrayAttribEXT(GLuint vaobj,GLuint index)
{
	static PFNDISABLEVERTEXARRAYATTRIBEXTPROC_HPP fn=reinterpret_cast<PFNDISABLEVERTEXARRAYATTRIBEXTPROC_HPP>(_impl::_get_proc_address("glDisableVertexArrayAttribEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,index);
}

typedef void (*PFNENABLEVERTEXARRAYEXTPROC_HPP)(GLuint vaobj,GLenum array);

static inline void EnableVertexArrayEXT(GLuint vaobj,GLenum array)
{
	static PFNENABLEVERTEXARRAYEXTPROC_HPP fn=reinterpret_cast<PFNENABLEVERTEXARRAYEXTPROC_HPP>(_impl::_get_proc_address("glEnableVertexArrayEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,array);
}

typedef void (*PFNDISABLEVERTEXARRAYEXTPROC_HPP)(GLuint vaobj,GLenum array);

static inline void DisableVertexArrayEXT(GLuint vaobj,GLenum array)
{
	static PFNDISABLEVERTEXARRAYEXTPROC_HPP fn=reinterpret_cast<PFNDISABLEVERTEXARRAYEXTPROC_HPP>(_impl::_get_proc_address("glDisableVertexArrayEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,array);
}

typedef void (*PFNVERTEXARRAYCOLOROFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayColorOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYCOLOROFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYCOLOROFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayColorOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYEDGEFLAGOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLsizei stride,GLintptr offset);

static inline void VertexArrayEdgeFlagOffsetEXT(GLuint vaobj,GLuint buffer,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYEDGEFLAGOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYEDGEFLAGOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayEdgeFlagOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,stride,offset);
}

typedef void (*PFNVERTEXARRAYFOGCOORDOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayFogCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYFOGCOORDOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYFOGCOORDOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayFogCoordOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYINDEXOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayIndexOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYINDEXOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYINDEXOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayIndexOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLenum texunit,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayMultiTexCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLenum texunit,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYMULTITEXCOORDOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayMultiTexCoordOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,texunit,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYNORMALOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayNormalOffsetEXT(GLuint vaobj,GLuint buffer,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYNORMALOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYNORMALOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayNormalOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArraySecondaryColorOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYSECONDARYCOLOROFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArraySecondaryColorOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYTEXCOORDOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayTexCoordOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYTEXCOORDOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYTEXCOORDOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayTexCoordOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYVERTEXOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayVertexOffsetEXT(GLuint vaobj,GLuint buffer,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYVERTEXOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayVertexAttribIOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribIOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,index,size,type,stride,offset);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLintptr offset);

static inline void VertexArrayVertexAttribOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribOffsetEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,buffer,index,size,type,normalized,stride,offset);
}

typedef void (*PFNGETVERTEXARRAYINTEGERVEXTPROC_HPP)(GLuint vaobj,GLenum pname,GLint *param);

static inline void GetVertexArrayIntegervEXT(GLuint vaobj,GLenum pname,GLint *param)
{
	static PFNGETVERTEXARRAYINTEGERVEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXARRAYINTEGERVEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexArrayIntegervEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,pname,param);
}

typedef void (*PFNGETVERTEXARRAYPOINTERVEXTPROC_HPP)(GLuint vaobj,GLenum pname,GLvoid* *param);

static inline void GetVertexArrayPointervEXT(GLuint vaobj,GLenum pname,GLvoid* *param)
{
	static PFNGETVERTEXARRAYPOINTERVEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXARRAYPOINTERVEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexArrayPointervEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,pname,param);
}

typedef void (*PFNGETVERTEXARRAYINTEGERI_VEXTPROC_HPP)(GLuint vaobj,GLuint index,GLenum pname,GLint *param);

static inline void GetVertexArrayIntegeri_vEXT(GLuint vaobj,GLuint index,GLenum pname,GLint *param)
{
	static PFNGETVERTEXARRAYINTEGERI_VEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXARRAYINTEGERI_VEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexArrayIntegeri_vEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,index,pname,param);
}

typedef void (*PFNGETVERTEXARRAYPOINTERI_VEXTPROC_HPP)(GLuint vaobj,GLuint index,GLenum pname,GLvoid* *param);

static inline void GetVertexArrayPointeri_vEXT(GLuint vaobj,GLuint index,GLenum pname,GLvoid* *param)
{
	static PFNGETVERTEXARRAYPOINTERI_VEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXARRAYPOINTERI_VEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexArrayPointeri_vEXT","GL_EXT_direct_state_access"));
	 fn(vaobj,index,pname,param);
}
#ifndef GL_EXT_discard_framebuffer

#define GL_EXT_discard_framebuffer
#ifndef GL_COLOR_EXT
#define GL_COLOR_EXT                                                    0x1800
#endif //GL_COLOR_EXT
#ifndef GL_DEPTH_EXT
#define GL_DEPTH_EXT                                                    0x1801
#endif //GL_DEPTH_EXT
#ifndef GL_STENCIL_EXT
#define GL_STENCIL_EXT                                                  0x1802
#endif //GL_STENCIL_EXT

#endif //GL_EXT_discard_framebuffer

#ifndef GL_EXT_draw_buffers2

#define GL_EXT_draw_buffers2

#endif //GL_EXT_draw_buffers2


typedef void (*PFNCOLORMASKINDEXEDEXTPROC_HPP)(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a);

static inline void ColorMaskIndexedEXT(GLuint index,GLboolean r,GLboolean g,GLboolean b,GLboolean a)
{
	static PFNCOLORMASKINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNCOLORMASKINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glColorMaskIndexedEXT","GL_EXT_draw_buffers2"));
	 fn(index,r,g,b,a);
}

typedef void (*PFNGETBOOLEANINDEXEDVEXTPROC_HPP)(GLenum target,GLuint index,GLboolean *data);

static inline void GetBooleanIndexedvEXT(GLenum target,GLuint index,GLboolean *data)
{
	static PFNGETBOOLEANINDEXEDVEXTPROC_HPP fn=reinterpret_cast<PFNGETBOOLEANINDEXEDVEXTPROC_HPP>(_impl::_get_proc_address("glGetBooleanIndexedvEXT","GL_EXT_draw_buffers2"));
	 fn(target,index,data);
}

typedef void (*PFNGETINTEGERINDEXEDVEXTPROC_HPP)(GLenum target,GLuint index,GLint *data);

static inline void GetIntegerIndexedvEXT(GLenum target,GLuint index,GLint *data)
{
	static PFNGETINTEGERINDEXEDVEXTPROC_HPP fn=reinterpret_cast<PFNGETINTEGERINDEXEDVEXTPROC_HPP>(_impl::_get_proc_address("glGetIntegerIndexedvEXT","GL_EXT_draw_buffers2"));
	 fn(target,index,data);
}

typedef void (*PFNENABLEINDEXEDEXTPROC_HPP)(GLenum target,GLuint index);

static inline void EnableIndexedEXT(GLenum target,GLuint index)
{
	static PFNENABLEINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNENABLEINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glEnableIndexedEXT","GL_EXT_draw_buffers2"));
	 fn(target,index);
}

typedef void (*PFNDISABLEINDEXEDEXTPROC_HPP)(GLenum target,GLuint index);

static inline void DisableIndexedEXT(GLenum target,GLuint index)
{
	static PFNDISABLEINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNDISABLEINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glDisableIndexedEXT","GL_EXT_draw_buffers2"));
	 fn(target,index);
}

typedef GLboolean (*PFNISENABLEDINDEXEDEXTPROC_HPP)(GLenum target,GLuint index);

static inline GLboolean IsEnabledIndexedEXT(GLenum target,GLuint index)
{
	static PFNISENABLEDINDEXEDEXTPROC_HPP fn=reinterpret_cast<PFNISENABLEDINDEXEDEXTPROC_HPP>(_impl::_get_proc_address("glIsEnabledIndexedEXT","GL_EXT_draw_buffers2"));
	return fn(target,index);
}
#ifndef GL_EXT_draw_instanced

#define GL_EXT_draw_instanced

#endif //GL_EXT_draw_instanced


typedef void (*PFNDRAWARRAYSINSTANCEDEXTPROC_HPP)(GLenum mode,GLint start,GLsizei count,GLsizei primcount);

static inline void DrawArraysInstancedEXT(GLenum mode,GLint start,GLsizei count,GLsizei primcount)
{
	static PFNDRAWARRAYSINSTANCEDEXTPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSINSTANCEDEXTPROC_HPP>(_impl::_get_proc_address("glDrawArraysInstancedEXT","GL_EXT_draw_instanced"));
	 fn(mode,start,count,primcount);
}

typedef void (*PFNDRAWELEMENTSINSTANCEDEXTPROC_HPP)(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei primcount);

static inline void DrawElementsInstancedEXT(GLenum mode,GLsizei count,GLenum type,const GLvoid *indices,GLsizei primcount)
{
	static PFNDRAWELEMENTSINSTANCEDEXTPROC_HPP fn=reinterpret_cast<PFNDRAWELEMENTSINSTANCEDEXTPROC_HPP>(_impl::_get_proc_address("glDrawElementsInstancedEXT","GL_EXT_draw_instanced"));
	 fn(mode,count,type,indices,primcount);
}
#ifndef GL_EXT_draw_range_elements

#define GL_EXT_draw_range_elements

#endif //GL_EXT_draw_range_elements


typedef void (*PFNDRAWRANGEELEMENTSEXTPROC_HPP)(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices);

static inline void DrawRangeElementsEXT(GLenum mode,GLuint start,GLuint end,GLsizei count,GLenum type,const GLvoid *indices)
{
	static PFNDRAWRANGEELEMENTSEXTPROC_HPP fn=reinterpret_cast<PFNDRAWRANGEELEMENTSEXTPROC_HPP>(_impl::_get_proc_address("glDrawRangeElementsEXT","GL_EXT_draw_range_elements"));
	 fn(mode,start,end,count,type,indices);
}
#ifndef GL_EXT_fog_coord

#define GL_EXT_fog_coord
#ifndef GL_FOG_COORDINATE_SOURCE_EXT
#define GL_FOG_COORDINATE_SOURCE_EXT                                    0x8450
#endif //GL_FOG_COORDINATE_SOURCE_EXT
#ifndef GL_FOG_COORDINATE_EXT
#define GL_FOG_COORDINATE_EXT                                           0x8451
#endif //GL_FOG_COORDINATE_EXT
#ifndef GL_FRAGMENT_DEPTH_EXT
#define GL_FRAGMENT_DEPTH_EXT                                           0x8452
#endif //GL_FRAGMENT_DEPTH_EXT
#ifndef GL_CURRENT_FOG_COORDINATE_EXT
#define GL_CURRENT_FOG_COORDINATE_EXT                                   0x8453
#endif //GL_CURRENT_FOG_COORDINATE_EXT
#ifndef GL_FOG_COORDINATE_ARRAY_TYPE_EXT
#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT                                0x8454
#endif //GL_FOG_COORDINATE_ARRAY_TYPE_EXT
#ifndef GL_FOG_COORDINATE_ARRAY_STRIDE_EXT
#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT                              0x8455
#endif //GL_FOG_COORDINATE_ARRAY_STRIDE_EXT
#ifndef GL_FOG_COORDINATE_ARRAY_POINTER_EXT
#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT                             0x8456
#endif //GL_FOG_COORDINATE_ARRAY_POINTER_EXT
#ifndef GL_FOG_COORDINATE_ARRAY_EXT
#define GL_FOG_COORDINATE_ARRAY_EXT                                     0x8457
#endif //GL_FOG_COORDINATE_ARRAY_EXT

#endif //GL_EXT_fog_coord


typedef void (*PFNFOGCOORDFEXTPROC_HPP)(GLfloat coord);

static inline void FogCoordfEXT(GLfloat coord)
{
	static PFNFOGCOORDFEXTPROC_HPP fn=reinterpret_cast<PFNFOGCOORDFEXTPROC_HPP>(_impl::_get_proc_address("glFogCoordfEXT","GL_EXT_fog_coord"));
	 fn(coord);
}

typedef void (*PFNFOGCOORDFVEXTPROC_HPP)(const GLfloat *coord);

static inline void FogCoordfvEXT(const GLfloat *coord)
{
	static PFNFOGCOORDFVEXTPROC_HPP fn=reinterpret_cast<PFNFOGCOORDFVEXTPROC_HPP>(_impl::_get_proc_address("glFogCoordfvEXT","GL_EXT_fog_coord"));
	 fn(coord);
}

typedef void (*PFNFOGCOORDDEXTPROC_HPP)(GLdouble coord);

static inline void FogCoorddEXT(GLdouble coord)
{
	static PFNFOGCOORDDEXTPROC_HPP fn=reinterpret_cast<PFNFOGCOORDDEXTPROC_HPP>(_impl::_get_proc_address("glFogCoorddEXT","GL_EXT_fog_coord"));
	 fn(coord);
}

typedef void (*PFNFOGCOORDDVEXTPROC_HPP)(const GLdouble *coord);

static inline void FogCoorddvEXT(const GLdouble *coord)
{
	static PFNFOGCOORDDVEXTPROC_HPP fn=reinterpret_cast<PFNFOGCOORDDVEXTPROC_HPP>(_impl::_get_proc_address("glFogCoorddvEXT","GL_EXT_fog_coord"));
	 fn(coord);
}

typedef void (*PFNFOGCOORDPOINTEREXTPROC_HPP)(GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void FogCoordPointerEXT(GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNFOGCOORDPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNFOGCOORDPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glFogCoordPointerEXT","GL_EXT_fog_coord"));
	 fn(type,stride,pointer);
}
#ifndef GL_EXT_framebuffer_blit

#define GL_EXT_framebuffer_blit
#ifndef GL_FRAMEBUFFER_BINDING_EXT
#define GL_FRAMEBUFFER_BINDING_EXT                                      0x8CA6
#endif //GL_FRAMEBUFFER_BINDING_EXT
#ifndef GL_DRAW_FRAMEBUFFER_BINDING_EXT
#define GL_DRAW_FRAMEBUFFER_BINDING_EXT                                 0x8CA6
#endif //GL_DRAW_FRAMEBUFFER_BINDING_EXT
#ifndef GL_READ_FRAMEBUFFER_EXT
#define GL_READ_FRAMEBUFFER_EXT                                         0x8CA8
#endif //GL_READ_FRAMEBUFFER_EXT
#ifndef GL_DRAW_FRAMEBUFFER_EXT
#define GL_DRAW_FRAMEBUFFER_EXT                                         0x8CA9
#endif //GL_DRAW_FRAMEBUFFER_EXT
#ifndef GL_READ_FRAMEBUFFER_BINDING_EXT
#define GL_READ_FRAMEBUFFER_BINDING_EXT                                 0x8CAA
#endif //GL_READ_FRAMEBUFFER_BINDING_EXT

#endif //GL_EXT_framebuffer_blit


typedef void (*PFNBLITFRAMEBUFFEREXTPROC_HPP)(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter);

static inline void BlitFramebufferEXT(GLint srcX0,GLint srcY0,GLint srcX1,GLint srcY1,GLint dstX0,GLint dstY0,GLint dstX1,GLint dstY1,GLbitfield mask,GLenum filter)
{
	static PFNBLITFRAMEBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNBLITFRAMEBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glBlitFramebufferEXT","GL_EXT_framebuffer_blit"));
	 fn(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter);
}
#ifndef GL_EXT_framebuffer_multisample

#define GL_EXT_framebuffer_multisample
#ifndef GL_RENDERBUFFER_SAMPLES_EXT
#define GL_RENDERBUFFER_SAMPLES_EXT                                     0x8CAB
#endif //GL_RENDERBUFFER_SAMPLES_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT                       0x8D56
#endif //GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT
#ifndef GL_MAX_SAMPLES_EXT
#define GL_MAX_SAMPLES_EXT                                              0x8D57
#endif //GL_MAX_SAMPLES_EXT

#endif //GL_EXT_framebuffer_multisample


typedef void (*PFNRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP)(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height);

static inline void RenderbufferStorageMultisampleEXT(GLenum target,GLsizei samples,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP fn=reinterpret_cast<PFNRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC_HPP>(_impl::_get_proc_address("glRenderbufferStorageMultisampleEXT","GL_EXT_framebuffer_multisample"));
	 fn(target,samples,internalformat,width,height);
}
#ifndef GL_EXT_framebuffer_multisample_blit_scaled

#define GL_EXT_framebuffer_multisample_blit_scaled
#ifndef GL_SCALED_RESOLVE_FASTEST_EXT
#define GL_SCALED_RESOLVE_FASTEST_EXT                                   0x90BA
#endif //GL_SCALED_RESOLVE_FASTEST_EXT
#ifndef GL_SCALED_RESOLVE_NICEST_EXT
#define GL_SCALED_RESOLVE_NICEST_EXT                                    0x90BB
#endif //GL_SCALED_RESOLVE_NICEST_EXT

#endif //GL_EXT_framebuffer_multisample_blit_scaled

#ifndef GL_EXT_framebuffer_object

#define GL_EXT_framebuffer_object
#ifndef GL_INVALID_FRAMEBUFFER_OPERATION_EXT
#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT                            0x0506
#endif //GL_INVALID_FRAMEBUFFER_OPERATION_EXT
#ifndef GL_MAX_RENDERBUFFER_SIZE_EXT
#define GL_MAX_RENDERBUFFER_SIZE_EXT                                    0x84E8
#endif //GL_MAX_RENDERBUFFER_SIZE_EXT
#ifndef GL_RENDERBUFFER_BINDING_EXT
#define GL_RENDERBUFFER_BINDING_EXT                                     0x8CA7
#endif //GL_RENDERBUFFER_BINDING_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE                           0x8CD0
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT                       0x8CD0
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME                           0x8CD1
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT                       0x8CD1
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL                         0x8CD2
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT                     0x8CD2
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE                 0x8CD3
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT             0x8CD3
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER                         0x8CD4
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT                0x8CD4
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT
#ifndef GL_FRAMEBUFFER_COMPLETE
#define GL_FRAMEBUFFER_COMPLETE                                         0x8CD5
#endif //GL_FRAMEBUFFER_COMPLETE
#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT                                     0x8CD5
#endif //GL_FRAMEBUFFER_COMPLETE_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT                        0x8CD6
#endif //GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT                            0x8CD6
#endif //GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT                0x8CD7
#endif //GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT                    0x8CD7
#endif //GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT                        0x8CD9
#endif //GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT                           0x8CDA
#endif //GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT                       0x8CDB
#endif //GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER                           0x8CDB
#endif //GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
#ifndef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT                       0x8CDC
#endif //GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER                           0x8CDC
#endif //GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
#ifndef GL_FRAMEBUFFER_UNSUPPORTED_EXT
#define GL_FRAMEBUFFER_UNSUPPORTED_EXT                                  0x8CDD
#endif //GL_FRAMEBUFFER_UNSUPPORTED_EXT
#ifndef GL_FRAMEBUFFER_UNSUPPORTED
#define GL_FRAMEBUFFER_UNSUPPORTED                                      0x8CDD
#endif //GL_FRAMEBUFFER_UNSUPPORTED
#ifndef GL_MAX_COLOR_ATTACHMENTS
#define GL_MAX_COLOR_ATTACHMENTS                                        0x8CDF
#endif //GL_MAX_COLOR_ATTACHMENTS
#ifndef GL_MAX_COLOR_ATTACHMENTS_EXT
#define GL_MAX_COLOR_ATTACHMENTS_EXT                                    0x8CDF
#endif //GL_MAX_COLOR_ATTACHMENTS_EXT
#ifndef GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT                                        0x8CE0
#endif //GL_COLOR_ATTACHMENT0_EXT
#ifndef GL_COLOR_ATTACHMENT0
#define GL_COLOR_ATTACHMENT0                                            0x8CE0
#endif //GL_COLOR_ATTACHMENT0
#ifndef GL_COLOR_ATTACHMENT1
#define GL_COLOR_ATTACHMENT1                                            0x8CE1
#endif //GL_COLOR_ATTACHMENT1
#ifndef GL_COLOR_ATTACHMENT1_EXT
#define GL_COLOR_ATTACHMENT1_EXT                                        0x8CE1
#endif //GL_COLOR_ATTACHMENT1_EXT
#ifndef GL_COLOR_ATTACHMENT2_EXT
#define GL_COLOR_ATTACHMENT2_EXT                                        0x8CE2
#endif //GL_COLOR_ATTACHMENT2_EXT
#ifndef GL_COLOR_ATTACHMENT2
#define GL_COLOR_ATTACHMENT2                                            0x8CE2
#endif //GL_COLOR_ATTACHMENT2
#ifndef GL_COLOR_ATTACHMENT3
#define GL_COLOR_ATTACHMENT3                                            0x8CE3
#endif //GL_COLOR_ATTACHMENT3
#ifndef GL_COLOR_ATTACHMENT3_EXT
#define GL_COLOR_ATTACHMENT3_EXT                                        0x8CE3
#endif //GL_COLOR_ATTACHMENT3_EXT
#ifndef GL_COLOR_ATTACHMENT4_EXT
#define GL_COLOR_ATTACHMENT4_EXT                                        0x8CE4
#endif //GL_COLOR_ATTACHMENT4_EXT
#ifndef GL_COLOR_ATTACHMENT4
#define GL_COLOR_ATTACHMENT4                                            0x8CE4
#endif //GL_COLOR_ATTACHMENT4
#ifndef GL_COLOR_ATTACHMENT5_EXT
#define GL_COLOR_ATTACHMENT5_EXT                                        0x8CE5
#endif //GL_COLOR_ATTACHMENT5_EXT
#ifndef GL_COLOR_ATTACHMENT5
#define GL_COLOR_ATTACHMENT5                                            0x8CE5
#endif //GL_COLOR_ATTACHMENT5
#ifndef GL_COLOR_ATTACHMENT6
#define GL_COLOR_ATTACHMENT6                                            0x8CE6
#endif //GL_COLOR_ATTACHMENT6
#ifndef GL_COLOR_ATTACHMENT6_EXT
#define GL_COLOR_ATTACHMENT6_EXT                                        0x8CE6
#endif //GL_COLOR_ATTACHMENT6_EXT
#ifndef GL_COLOR_ATTACHMENT7_EXT
#define GL_COLOR_ATTACHMENT7_EXT                                        0x8CE7
#endif //GL_COLOR_ATTACHMENT7_EXT
#ifndef GL_COLOR_ATTACHMENT7
#define GL_COLOR_ATTACHMENT7                                            0x8CE7
#endif //GL_COLOR_ATTACHMENT7
#ifndef GL_COLOR_ATTACHMENT8
#define GL_COLOR_ATTACHMENT8                                            0x8CE8
#endif //GL_COLOR_ATTACHMENT8
#ifndef GL_COLOR_ATTACHMENT8_EXT
#define GL_COLOR_ATTACHMENT8_EXT                                        0x8CE8
#endif //GL_COLOR_ATTACHMENT8_EXT
#ifndef GL_COLOR_ATTACHMENT9_EXT
#define GL_COLOR_ATTACHMENT9_EXT                                        0x8CE9
#endif //GL_COLOR_ATTACHMENT9_EXT
#ifndef GL_COLOR_ATTACHMENT9
#define GL_COLOR_ATTACHMENT9                                            0x8CE9
#endif //GL_COLOR_ATTACHMENT9
#ifndef GL_COLOR_ATTACHMENT10_EXT
#define GL_COLOR_ATTACHMENT10_EXT                                       0x8CEA
#endif //GL_COLOR_ATTACHMENT10_EXT
#ifndef GL_COLOR_ATTACHMENT10
#define GL_COLOR_ATTACHMENT10                                           0x8CEA
#endif //GL_COLOR_ATTACHMENT10
#ifndef GL_COLOR_ATTACHMENT11_EXT
#define GL_COLOR_ATTACHMENT11_EXT                                       0x8CEB
#endif //GL_COLOR_ATTACHMENT11_EXT
#ifndef GL_COLOR_ATTACHMENT11
#define GL_COLOR_ATTACHMENT11                                           0x8CEB
#endif //GL_COLOR_ATTACHMENT11
#ifndef GL_COLOR_ATTACHMENT12
#define GL_COLOR_ATTACHMENT12                                           0x8CEC
#endif //GL_COLOR_ATTACHMENT12
#ifndef GL_COLOR_ATTACHMENT12_EXT
#define GL_COLOR_ATTACHMENT12_EXT                                       0x8CEC
#endif //GL_COLOR_ATTACHMENT12_EXT
#ifndef GL_COLOR_ATTACHMENT13_EXT
#define GL_COLOR_ATTACHMENT13_EXT                                       0x8CED
#endif //GL_COLOR_ATTACHMENT13_EXT
#ifndef GL_COLOR_ATTACHMENT13
#define GL_COLOR_ATTACHMENT13                                           0x8CED
#endif //GL_COLOR_ATTACHMENT13
#ifndef GL_COLOR_ATTACHMENT14_EXT
#define GL_COLOR_ATTACHMENT14_EXT                                       0x8CEE
#endif //GL_COLOR_ATTACHMENT14_EXT
#ifndef GL_COLOR_ATTACHMENT14
#define GL_COLOR_ATTACHMENT14                                           0x8CEE
#endif //GL_COLOR_ATTACHMENT14
#ifndef GL_COLOR_ATTACHMENT15_EXT
#define GL_COLOR_ATTACHMENT15_EXT                                       0x8CEF
#endif //GL_COLOR_ATTACHMENT15_EXT
#ifndef GL_COLOR_ATTACHMENT15
#define GL_COLOR_ATTACHMENT15                                           0x8CEF
#endif //GL_COLOR_ATTACHMENT15
#ifndef GL_DEPTH_ATTACHMENT
#define GL_DEPTH_ATTACHMENT                                             0x8D00
#endif //GL_DEPTH_ATTACHMENT
#ifndef GL_DEPTH_ATTACHMENT_EXT
#define GL_DEPTH_ATTACHMENT_EXT                                         0x8D00
#endif //GL_DEPTH_ATTACHMENT_EXT
#ifndef GL_STENCIL_ATTACHMENT
#define GL_STENCIL_ATTACHMENT                                           0x8D20
#endif //GL_STENCIL_ATTACHMENT
#ifndef GL_STENCIL_ATTACHMENT_EXT
#define GL_STENCIL_ATTACHMENT_EXT                                       0x8D20
#endif //GL_STENCIL_ATTACHMENT_EXT
#ifndef GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT                                              0x8D40
#endif //GL_FRAMEBUFFER_EXT
#ifndef GL_FRAMEBUFFER
#define GL_FRAMEBUFFER                                                  0x8D40
#endif //GL_FRAMEBUFFER
#ifndef GL_RENDERBUFFER
#define GL_RENDERBUFFER                                                 0x8D41
#endif //GL_RENDERBUFFER
#ifndef GL_RENDERBUFFER_EXT
#define GL_RENDERBUFFER_EXT                                             0x8D41
#endif //GL_RENDERBUFFER_EXT
#ifndef GL_RENDERBUFFER_WIDTH
#define GL_RENDERBUFFER_WIDTH                                           0x8D42
#endif //GL_RENDERBUFFER_WIDTH
#ifndef GL_RENDERBUFFER_WIDTH_EXT
#define GL_RENDERBUFFER_WIDTH_EXT                                       0x8D42
#endif //GL_RENDERBUFFER_WIDTH_EXT
#ifndef GL_RENDERBUFFER_HEIGHT
#define GL_RENDERBUFFER_HEIGHT                                          0x8D43
#endif //GL_RENDERBUFFER_HEIGHT
#ifndef GL_RENDERBUFFER_HEIGHT_EXT
#define GL_RENDERBUFFER_HEIGHT_EXT                                      0x8D43
#endif //GL_RENDERBUFFER_HEIGHT_EXT
#ifndef GL_RENDERBUFFER_INTERNAL_FORMAT
#define GL_RENDERBUFFER_INTERNAL_FORMAT                                 0x8D44
#endif //GL_RENDERBUFFER_INTERNAL_FORMAT
#ifndef GL_RENDERBUFFER_INTERNAL_FORMAT_EXT
#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT                             0x8D44
#endif //GL_RENDERBUFFER_INTERNAL_FORMAT_EXT
#ifndef GL_STENCIL_INDEX1
#define GL_STENCIL_INDEX1                                               0x8D46
#endif //GL_STENCIL_INDEX1
#ifndef GL_STENCIL_INDEX1_EXT
#define GL_STENCIL_INDEX1_EXT                                           0x8D46
#endif //GL_STENCIL_INDEX1_EXT
#ifndef GL_STENCIL_INDEX4
#define GL_STENCIL_INDEX4                                               0x8D47
#endif //GL_STENCIL_INDEX4
#ifndef GL_STENCIL_INDEX4_EXT
#define GL_STENCIL_INDEX4_EXT                                           0x8D47
#endif //GL_STENCIL_INDEX4_EXT
#ifndef GL_STENCIL_INDEX8_EXT
#define GL_STENCIL_INDEX8_EXT                                           0x8D48
#endif //GL_STENCIL_INDEX8_EXT
#ifndef GL_STENCIL_INDEX8
#define GL_STENCIL_INDEX8                                               0x8D48
#endif //GL_STENCIL_INDEX8
#ifndef GL_STENCIL_INDEX16
#define GL_STENCIL_INDEX16                                              0x8D49
#endif //GL_STENCIL_INDEX16
#ifndef GL_STENCIL_INDEX16_EXT
#define GL_STENCIL_INDEX16_EXT                                          0x8D49
#endif //GL_STENCIL_INDEX16_EXT
#ifndef GL_RENDERBUFFER_RED_SIZE
#define GL_RENDERBUFFER_RED_SIZE                                        0x8D50
#endif //GL_RENDERBUFFER_RED_SIZE
#ifndef GL_RENDERBUFFER_RED_SIZE_EXT
#define GL_RENDERBUFFER_RED_SIZE_EXT                                    0x8D50
#endif //GL_RENDERBUFFER_RED_SIZE_EXT
#ifndef GL_RENDERBUFFER_GREEN_SIZE
#define GL_RENDERBUFFER_GREEN_SIZE                                      0x8D51
#endif //GL_RENDERBUFFER_GREEN_SIZE
#ifndef GL_RENDERBUFFER_GREEN_SIZE_EXT
#define GL_RENDERBUFFER_GREEN_SIZE_EXT                                  0x8D51
#endif //GL_RENDERBUFFER_GREEN_SIZE_EXT
#ifndef GL_RENDERBUFFER_BLUE_SIZE_EXT
#define GL_RENDERBUFFER_BLUE_SIZE_EXT                                   0x8D52
#endif //GL_RENDERBUFFER_BLUE_SIZE_EXT
#ifndef GL_RENDERBUFFER_BLUE_SIZE
#define GL_RENDERBUFFER_BLUE_SIZE                                       0x8D52
#endif //GL_RENDERBUFFER_BLUE_SIZE
#ifndef GL_RENDERBUFFER_ALPHA_SIZE_EXT
#define GL_RENDERBUFFER_ALPHA_SIZE_EXT                                  0x8D53
#endif //GL_RENDERBUFFER_ALPHA_SIZE_EXT
#ifndef GL_RENDERBUFFER_ALPHA_SIZE
#define GL_RENDERBUFFER_ALPHA_SIZE                                      0x8D53
#endif //GL_RENDERBUFFER_ALPHA_SIZE
#ifndef GL_RENDERBUFFER_DEPTH_SIZE
#define GL_RENDERBUFFER_DEPTH_SIZE                                      0x8D54
#endif //GL_RENDERBUFFER_DEPTH_SIZE
#ifndef GL_RENDERBUFFER_DEPTH_SIZE_EXT
#define GL_RENDERBUFFER_DEPTH_SIZE_EXT                                  0x8D54
#endif //GL_RENDERBUFFER_DEPTH_SIZE_EXT
#ifndef GL_RENDERBUFFER_STENCIL_SIZE_EXT
#define GL_RENDERBUFFER_STENCIL_SIZE_EXT                                0x8D55
#endif //GL_RENDERBUFFER_STENCIL_SIZE_EXT
#ifndef GL_RENDERBUFFER_STENCIL_SIZE
#define GL_RENDERBUFFER_STENCIL_SIZE                                    0x8D55
#endif //GL_RENDERBUFFER_STENCIL_SIZE

#endif //GL_EXT_framebuffer_object


typedef GLboolean (*PFNISRENDERBUFFEREXTPROC_HPP)(GLuint renderbuffer);

static inline GLboolean IsRenderbufferEXT(GLuint renderbuffer)
{
	static PFNISRENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNISRENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glIsRenderbufferEXT","GL_EXT_framebuffer_object"));
	return fn(renderbuffer);
}

typedef void (*PFNBINDRENDERBUFFEREXTPROC_HPP)(GLenum target,GLuint renderbuffer);

static inline void BindRenderbufferEXT(GLenum target,GLuint renderbuffer)
{
	static PFNBINDRENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNBINDRENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glBindRenderbufferEXT","GL_EXT_framebuffer_object"));
	 fn(target,renderbuffer);
}

typedef void (*PFNDELETERENDERBUFFERSEXTPROC_HPP)(GLsizei n,const GLuint *renderbuffers);

static inline void DeleteRenderbuffersEXT(GLsizei n,const GLuint *renderbuffers)
{
	static PFNDELETERENDERBUFFERSEXTPROC_HPP fn=reinterpret_cast<PFNDELETERENDERBUFFERSEXTPROC_HPP>(_impl::_get_proc_address("glDeleteRenderbuffersEXT","GL_EXT_framebuffer_object"));
	 fn(n,renderbuffers);
}

typedef void (*PFNGENRENDERBUFFERSEXTPROC_HPP)(GLsizei n,GLuint *renderbuffers);

static inline void GenRenderbuffersEXT(GLsizei n,GLuint *renderbuffers)
{
	static PFNGENRENDERBUFFERSEXTPROC_HPP fn=reinterpret_cast<PFNGENRENDERBUFFERSEXTPROC_HPP>(_impl::_get_proc_address("glGenRenderbuffersEXT","GL_EXT_framebuffer_object"));
	 fn(n,renderbuffers);
}

typedef void (*PFNRENDERBUFFERSTORAGEEXTPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLsizei height);

static inline void RenderbufferStorageEXT(GLenum target,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNRENDERBUFFERSTORAGEEXTPROC_HPP fn=reinterpret_cast<PFNRENDERBUFFERSTORAGEEXTPROC_HPP>(_impl::_get_proc_address("glRenderbufferStorageEXT","GL_EXT_framebuffer_object"));
	 fn(target,internalformat,width,height);
}

typedef void (*PFNGETRENDERBUFFERPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetRenderbufferParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETRENDERBUFFERPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETRENDERBUFFERPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetRenderbufferParameterivEXT","GL_EXT_framebuffer_object"));
	 fn(target,pname,params);
}

typedef GLboolean (*PFNISFRAMEBUFFEREXTPROC_HPP)(GLuint framebuffer);

static inline GLboolean IsFramebufferEXT(GLuint framebuffer)
{
	static PFNISFRAMEBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNISFRAMEBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glIsFramebufferEXT","GL_EXT_framebuffer_object"));
	return fn(framebuffer);
}

typedef void (*PFNBINDFRAMEBUFFEREXTPROC_HPP)(GLenum target,GLuint framebuffer);

static inline void BindFramebufferEXT(GLenum target,GLuint framebuffer)
{
	static PFNBINDFRAMEBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNBINDFRAMEBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glBindFramebufferEXT","GL_EXT_framebuffer_object"));
	 fn(target,framebuffer);
}

typedef void (*PFNDELETEFRAMEBUFFERSEXTPROC_HPP)(GLsizei n,const GLuint *framebuffers);

static inline void DeleteFramebuffersEXT(GLsizei n,const GLuint *framebuffers)
{
	static PFNDELETEFRAMEBUFFERSEXTPROC_HPP fn=reinterpret_cast<PFNDELETEFRAMEBUFFERSEXTPROC_HPP>(_impl::_get_proc_address("glDeleteFramebuffersEXT","GL_EXT_framebuffer_object"));
	 fn(n,framebuffers);
}

typedef void (*PFNGENFRAMEBUFFERSEXTPROC_HPP)(GLsizei n,GLuint *framebuffers);

static inline void GenFramebuffersEXT(GLsizei n,GLuint *framebuffers)
{
	static PFNGENFRAMEBUFFERSEXTPROC_HPP fn=reinterpret_cast<PFNGENFRAMEBUFFERSEXTPROC_HPP>(_impl::_get_proc_address("glGenFramebuffersEXT","GL_EXT_framebuffer_object"));
	 fn(n,framebuffers);
}

typedef GLenum (*PFNCHECKFRAMEBUFFERSTATUSEXTPROC_HPP)(GLenum target);

static inline GLenum CheckFramebufferStatusEXT(GLenum target)
{
	static PFNCHECKFRAMEBUFFERSTATUSEXTPROC_HPP fn=reinterpret_cast<PFNCHECKFRAMEBUFFERSTATUSEXTPROC_HPP>(_impl::_get_proc_address("glCheckFramebufferStatusEXT","GL_EXT_framebuffer_object"));
	return fn(target);
}

typedef void (*PFNFRAMEBUFFERTEXTURE1DEXTPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void FramebufferTexture1DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTURE1DEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE1DEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture1DEXT","GL_EXT_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURE2DEXTPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level);

static inline void FramebufferTexture2DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTURE2DEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE2DEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture2DEXT","GL_EXT_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURE3DEXTPROC_HPP)(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset);

static inline void FramebufferTexture3DEXT(GLenum target,GLenum attachment,GLenum textarget,GLuint texture,GLint level,GLint zoffset)
{
	static PFNFRAMEBUFFERTEXTURE3DEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURE3DEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTexture3DEXT","GL_EXT_framebuffer_object"));
	 fn(target,attachment,textarget,texture,level,zoffset);
}

typedef void (*PFNFRAMEBUFFERRENDERBUFFEREXTPROC_HPP)(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer);

static inline void FramebufferRenderbufferEXT(GLenum target,GLenum attachment,GLenum renderbuffertarget,GLuint renderbuffer)
{
	static PFNFRAMEBUFFERRENDERBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERRENDERBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glFramebufferRenderbufferEXT","GL_EXT_framebuffer_object"));
	 fn(target,attachment,renderbuffertarget,renderbuffer);
}

typedef void (*PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum attachment,GLenum pname,GLint *params);

static inline void GetFramebufferAttachmentParameterivEXT(GLenum target,GLenum attachment,GLenum pname,GLint *params)
{
	static PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetFramebufferAttachmentParameterivEXT","GL_EXT_framebuffer_object"));
	 fn(target,attachment,pname,params);
}

typedef void (*PFNGENERATEMIPMAPEXTPROC_HPP)(GLenum target);

static inline void GenerateMipmapEXT(GLenum target)
{
	static PFNGENERATEMIPMAPEXTPROC_HPP fn=reinterpret_cast<PFNGENERATEMIPMAPEXTPROC_HPP>(_impl::_get_proc_address("glGenerateMipmapEXT","GL_EXT_framebuffer_object"));
	 fn(target);
}
#ifndef GL_EXT_framebuffer_sRGB

#define GL_EXT_framebuffer_sRGB
#ifndef GL_FRAMEBUFFER_SRGB_EXT
#define GL_FRAMEBUFFER_SRGB_EXT                                         0x8DB9
#endif //GL_FRAMEBUFFER_SRGB_EXT
#ifndef GL_FRAMEBUFFER_SRGB_CAPABLE_EXT
#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT                                 0x8DBA
#endif //GL_FRAMEBUFFER_SRGB_CAPABLE_EXT

#endif //GL_EXT_framebuffer_sRGB

#ifndef GL_EXT_geometry_shader4

#define GL_EXT_geometry_shader4
#ifndef GL_MAX_VARYING_COMPONENTS_EXT
#define GL_MAX_VARYING_COMPONENTS_EXT                                   0x8B4B
#endif //GL_MAX_VARYING_COMPONENTS_EXT
#ifndef GL_GEOMETRY_SHADER_EXT
#define GL_GEOMETRY_SHADER_EXT                                          0x8DD9
#endif //GL_GEOMETRY_SHADER_EXT
#ifndef GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT
#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT                          0x8DDD
#endif //GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT
#ifndef GL_MAX_VERTEX_VARYING_COMPONENTS_EXT
#define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT                            0x8DDE
#endif //GL_MAX_VERTEX_VARYING_COMPONENTS_EXT
#ifndef GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT
#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT                          0x8DDF
#endif //GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT
#ifndef GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT
#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT                             0x8DE0
#endif //GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT
#ifndef GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT
#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT                     0x8DE1
#endif //GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT

#endif //GL_EXT_geometry_shader4


typedef void (*PFNPROGRAMPARAMETERIEXTPROC_HPP)(GLuint program,GLenum pname,GLint value);

static inline void ProgramParameteriEXT(GLuint program,GLenum pname,GLint value)
{
	static PFNPROGRAMPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glProgramParameteriEXT","GL_EXT_geometry_shader4"));
	 fn(program,pname,value);
}
#ifndef GL_EXT_gpu_program_parameters

#define GL_EXT_gpu_program_parameters

#endif //GL_EXT_gpu_program_parameters


typedef void (*PFNPROGRAMENVPARAMETERS4FVEXTPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLfloat *params);

static inline void ProgramEnvParameters4fvEXT(GLenum target,GLuint index,GLsizei count,const GLfloat *params)
{
	static PFNPROGRAMENVPARAMETERS4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERS4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameters4fvEXT","GL_EXT_gpu_program_parameters"));
	 fn(target,index,count,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLfloat *params);

static inline void ProgramLocalParameters4fvEXT(GLenum target,GLuint index,GLsizei count,const GLfloat *params)
{
	static PFNPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERS4FVEXTPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameters4fvEXT","GL_EXT_gpu_program_parameters"));
	 fn(target,index,count,params);
}
#ifndef GL_EXT_gpu_shader4

#define GL_EXT_gpu_shader4
#ifndef GL_SAMPLER_1D_ARRAY_EXT
#define GL_SAMPLER_1D_ARRAY_EXT                                         0x8DC0
#endif //GL_SAMPLER_1D_ARRAY_EXT
#ifndef GL_SAMPLER_2D_ARRAY_EXT
#define GL_SAMPLER_2D_ARRAY_EXT                                         0x8DC1
#endif //GL_SAMPLER_2D_ARRAY_EXT
#ifndef GL_SAMPLER_BUFFER_EXT
#define GL_SAMPLER_BUFFER_EXT                                           0x8DC2
#endif //GL_SAMPLER_BUFFER_EXT
#ifndef GL_SAMPLER_1D_ARRAY_SHADOW_EXT
#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT                                  0x8DC3
#endif //GL_SAMPLER_1D_ARRAY_SHADOW_EXT
#ifndef GL_SAMPLER_2D_ARRAY_SHADOW_EXT
#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT                                  0x8DC4
#endif //GL_SAMPLER_2D_ARRAY_SHADOW_EXT
#ifndef GL_SAMPLER_CUBE_SHADOW_EXT
#define GL_SAMPLER_CUBE_SHADOW_EXT                                      0x8DC5
#endif //GL_SAMPLER_CUBE_SHADOW_EXT
#ifndef GL_UNSIGNED_INT_VEC2_EXT
#define GL_UNSIGNED_INT_VEC2_EXT                                        0x8DC6
#endif //GL_UNSIGNED_INT_VEC2_EXT
#ifndef GL_UNSIGNED_INT_VEC3_EXT
#define GL_UNSIGNED_INT_VEC3_EXT                                        0x8DC7
#endif //GL_UNSIGNED_INT_VEC3_EXT
#ifndef GL_UNSIGNED_INT_VEC4_EXT
#define GL_UNSIGNED_INT_VEC4_EXT                                        0x8DC8
#endif //GL_UNSIGNED_INT_VEC4_EXT
#ifndef GL_INT_SAMPLER_1D_EXT
#define GL_INT_SAMPLER_1D_EXT                                           0x8DC9
#endif //GL_INT_SAMPLER_1D_EXT
#ifndef GL_INT_SAMPLER_2D_EXT
#define GL_INT_SAMPLER_2D_EXT                                           0x8DCA
#endif //GL_INT_SAMPLER_2D_EXT
#ifndef GL_INT_SAMPLER_3D_EXT
#define GL_INT_SAMPLER_3D_EXT                                           0x8DCB
#endif //GL_INT_SAMPLER_3D_EXT
#ifndef GL_INT_SAMPLER_CUBE_EXT
#define GL_INT_SAMPLER_CUBE_EXT                                         0x8DCC
#endif //GL_INT_SAMPLER_CUBE_EXT
#ifndef GL_INT_SAMPLER_2D_RECT_EXT
#define GL_INT_SAMPLER_2D_RECT_EXT                                      0x8DCD
#endif //GL_INT_SAMPLER_2D_RECT_EXT
#ifndef GL_INT_SAMPLER_1D_ARRAY_EXT
#define GL_INT_SAMPLER_1D_ARRAY_EXT                                     0x8DCE
#endif //GL_INT_SAMPLER_1D_ARRAY_EXT
#ifndef GL_INT_SAMPLER_2D_ARRAY_EXT
#define GL_INT_SAMPLER_2D_ARRAY_EXT                                     0x8DCF
#endif //GL_INT_SAMPLER_2D_ARRAY_EXT
#ifndef GL_INT_SAMPLER_BUFFER_EXT
#define GL_INT_SAMPLER_BUFFER_EXT                                       0x8DD0
#endif //GL_INT_SAMPLER_BUFFER_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_1D_EXT
#define GL_UNSIGNED_INT_SAMPLER_1D_EXT                                  0x8DD1
#endif //GL_UNSIGNED_INT_SAMPLER_1D_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_EXT
#define GL_UNSIGNED_INT_SAMPLER_2D_EXT                                  0x8DD2
#endif //GL_UNSIGNED_INT_SAMPLER_2D_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_3D_EXT
#define GL_UNSIGNED_INT_SAMPLER_3D_EXT                                  0x8DD3
#endif //GL_UNSIGNED_INT_SAMPLER_3D_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_CUBE_EXT
#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT                                0x8DD4
#endif //GL_UNSIGNED_INT_SAMPLER_CUBE_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT
#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT                             0x8DD5
#endif //GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT
#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT                            0x8DD6
#endif //GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT
#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT                            0x8DD7
#endif //GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT
#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT                              0x8DD8
#endif //GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT

#endif //GL_EXT_gpu_shader4


typedef void (*PFNGETUNIFORMUIVEXTPROC_HPP)(GLuint program,GLint location,GLuint *params);

static inline void GetUniformuivEXT(GLuint program,GLint location,GLuint *params)
{
	static PFNGETUNIFORMUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetUniformuivEXT","GL_EXT_gpu_shader4"));
	 fn(program,location,params);
}

typedef void (*PFNBINDFRAGDATALOCATIONEXTPROC_HPP)(GLuint program,GLuint color,const GLchar *name);

static inline void BindFragDataLocationEXT(GLuint program,GLuint color,const GLchar *name)
{
	static PFNBINDFRAGDATALOCATIONEXTPROC_HPP fn=reinterpret_cast<PFNBINDFRAGDATALOCATIONEXTPROC_HPP>(_impl::_get_proc_address("glBindFragDataLocationEXT","GL_EXT_gpu_shader4"));
	 fn(program,color,name);
}

typedef GLint (*PFNGETFRAGDATALOCATIONEXTPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetFragDataLocationEXT(GLuint program,const GLchar *name)
{
	static PFNGETFRAGDATALOCATIONEXTPROC_HPP fn=reinterpret_cast<PFNGETFRAGDATALOCATIONEXTPROC_HPP>(_impl::_get_proc_address("glGetFragDataLocationEXT","GL_EXT_gpu_shader4"));
	return fn(program,name);
}

typedef void (*PFNUNIFORM1UIEXTPROC_HPP)(GLint location,GLuint v0);

static inline void Uniform1uiEXT(GLint location,GLuint v0)
{
	static PFNUNIFORM1UIEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UIEXTPROC_HPP>(_impl::_get_proc_address("glUniform1uiEXT","GL_EXT_gpu_shader4"));
	 fn(location,v0);
}

typedef void (*PFNUNIFORM2UIEXTPROC_HPP)(GLint location,GLuint v0,GLuint v1);

static inline void Uniform2uiEXT(GLint location,GLuint v0,GLuint v1)
{
	static PFNUNIFORM2UIEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UIEXTPROC_HPP>(_impl::_get_proc_address("glUniform2uiEXT","GL_EXT_gpu_shader4"));
	 fn(location,v0,v1);
}

typedef void (*PFNUNIFORM3UIEXTPROC_HPP)(GLint location,GLuint v0,GLuint v1,GLuint v2);

static inline void Uniform3uiEXT(GLint location,GLuint v0,GLuint v1,GLuint v2)
{
	static PFNUNIFORM3UIEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UIEXTPROC_HPP>(_impl::_get_proc_address("glUniform3uiEXT","GL_EXT_gpu_shader4"));
	 fn(location,v0,v1,v2);
}

typedef void (*PFNUNIFORM4UIEXTPROC_HPP)(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3);

static inline void Uniform4uiEXT(GLint location,GLuint v0,GLuint v1,GLuint v2,GLuint v3)
{
	static PFNUNIFORM4UIEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UIEXTPROC_HPP>(_impl::_get_proc_address("glUniform4uiEXT","GL_EXT_gpu_shader4"));
	 fn(location,v0,v1,v2,v3);
}

typedef void (*PFNUNIFORM1UIVEXTPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform1uivEXT(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM1UIVEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UIVEXTPROC_HPP>(_impl::_get_proc_address("glUniform1uivEXT","GL_EXT_gpu_shader4"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2UIVEXTPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform2uivEXT(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM2UIVEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UIVEXTPROC_HPP>(_impl::_get_proc_address("glUniform2uivEXT","GL_EXT_gpu_shader4"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3UIVEXTPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform3uivEXT(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM3UIVEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UIVEXTPROC_HPP>(_impl::_get_proc_address("glUniform3uivEXT","GL_EXT_gpu_shader4"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4UIVEXTPROC_HPP)(GLint location,GLsizei count,const GLuint *value);

static inline void Uniform4uivEXT(GLint location,GLsizei count,const GLuint *value)
{
	static PFNUNIFORM4UIVEXTPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UIVEXTPROC_HPP>(_impl::_get_proc_address("glUniform4uivEXT","GL_EXT_gpu_shader4"));
	 fn(location,count,value);
}
#ifndef GL_EXT_histogram

#define GL_EXT_histogram
#ifndef GL_HISTOGRAM_EXT
#define GL_HISTOGRAM_EXT                                                0x8024
#endif //GL_HISTOGRAM_EXT
#ifndef GL_PROXY_HISTOGRAM_EXT
#define GL_PROXY_HISTOGRAM_EXT                                          0x8025
#endif //GL_PROXY_HISTOGRAM_EXT
#ifndef GL_HISTOGRAM_WIDTH_EXT
#define GL_HISTOGRAM_WIDTH_EXT                                          0x8026
#endif //GL_HISTOGRAM_WIDTH_EXT
#ifndef GL_HISTOGRAM_FORMAT_EXT
#define GL_HISTOGRAM_FORMAT_EXT                                         0x8027
#endif //GL_HISTOGRAM_FORMAT_EXT
#ifndef GL_HISTOGRAM_RED_SIZE_EXT
#define GL_HISTOGRAM_RED_SIZE_EXT                                       0x8028
#endif //GL_HISTOGRAM_RED_SIZE_EXT
#ifndef GL_HISTOGRAM_GREEN_SIZE_EXT
#define GL_HISTOGRAM_GREEN_SIZE_EXT                                     0x8029
#endif //GL_HISTOGRAM_GREEN_SIZE_EXT
#ifndef GL_HISTOGRAM_BLUE_SIZE_EXT
#define GL_HISTOGRAM_BLUE_SIZE_EXT                                      0x802A
#endif //GL_HISTOGRAM_BLUE_SIZE_EXT
#ifndef GL_HISTOGRAM_ALPHA_SIZE_EXT
#define GL_HISTOGRAM_ALPHA_SIZE_EXT                                     0x802B
#endif //GL_HISTOGRAM_ALPHA_SIZE_EXT
#ifndef GL_HISTOGRAM_LUMINANCE_SIZE
#define GL_HISTOGRAM_LUMINANCE_SIZE                                     0x802C
#endif //GL_HISTOGRAM_LUMINANCE_SIZE
#ifndef GL_HISTOGRAM_LUMINANCE_SIZE_EXT
#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT                                 0x802C
#endif //GL_HISTOGRAM_LUMINANCE_SIZE_EXT
#ifndef GL_HISTOGRAM_SINK_EXT
#define GL_HISTOGRAM_SINK_EXT                                           0x802D
#endif //GL_HISTOGRAM_SINK_EXT
#ifndef GL_MINMAX_EXT
#define GL_MINMAX_EXT                                                   0x802E
#endif //GL_MINMAX_EXT
#ifndef GL_MINMAX_FORMAT_EXT
#define GL_MINMAX_FORMAT_EXT                                            0x802F
#endif //GL_MINMAX_FORMAT_EXT
#ifndef GL_MINMAX_SINK_EXT
#define GL_MINMAX_SINK_EXT                                              0x8030
#endif //GL_MINMAX_SINK_EXT
#ifndef GL_TABLE_TOO_LARGE_EXT
#define GL_TABLE_TOO_LARGE_EXT                                          0x8031
#endif //GL_TABLE_TOO_LARGE_EXT

#endif //GL_EXT_histogram


typedef void (*PFNGETHISTOGRAMEXTPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values);

static inline void GetHistogramEXT(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values)
{
	static PFNGETHISTOGRAMEXTPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMEXTPROC_HPP>(_impl::_get_proc_address("glGetHistogramEXT","GL_EXT_histogram"));
	 fn(target,reset,format,type,values);
}

typedef void (*PFNGETHISTOGRAMPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetHistogramParameterfvEXT(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETHISTOGRAMPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetHistogramParameterfvEXT","GL_EXT_histogram"));
	 fn(target,pname,params);
}

typedef void (*PFNGETHISTOGRAMPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetHistogramParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETHISTOGRAMPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETHISTOGRAMPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetHistogramParameterivEXT","GL_EXT_histogram"));
	 fn(target,pname,params);
}

typedef void (*PFNGETMINMAXEXTPROC_HPP)(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values);

static inline void GetMinmaxEXT(GLenum target,GLboolean reset,GLenum format,GLenum type,GLvoid *values)
{
	static PFNGETMINMAXEXTPROC_HPP fn=reinterpret_cast<PFNGETMINMAXEXTPROC_HPP>(_impl::_get_proc_address("glGetMinmaxEXT","GL_EXT_histogram"));
	 fn(target,reset,format,type,values);
}

typedef void (*PFNGETMINMAXPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetMinmaxParameterfvEXT(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETMINMAXPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETMINMAXPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetMinmaxParameterfvEXT","GL_EXT_histogram"));
	 fn(target,pname,params);
}

typedef void (*PFNGETMINMAXPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetMinmaxParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMINMAXPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETMINMAXPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetMinmaxParameterivEXT","GL_EXT_histogram"));
	 fn(target,pname,params);
}

typedef void (*PFNHISTOGRAMEXTPROC_HPP)(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink);

static inline void HistogramEXT(GLenum target,GLsizei width,GLenum internalformat,GLboolean sink)
{
	static PFNHISTOGRAMEXTPROC_HPP fn=reinterpret_cast<PFNHISTOGRAMEXTPROC_HPP>(_impl::_get_proc_address("glHistogramEXT","GL_EXT_histogram"));
	 fn(target,width,internalformat,sink);
}

typedef void (*PFNMINMAXEXTPROC_HPP)(GLenum target,GLenum internalformat,GLboolean sink);

static inline void MinmaxEXT(GLenum target,GLenum internalformat,GLboolean sink)
{
	static PFNMINMAXEXTPROC_HPP fn=reinterpret_cast<PFNMINMAXEXTPROC_HPP>(_impl::_get_proc_address("glMinmaxEXT","GL_EXT_histogram"));
	 fn(target,internalformat,sink);
}

typedef void (*PFNRESETHISTOGRAMEXTPROC_HPP)(GLenum target);

static inline void ResetHistogramEXT(GLenum target)
{
	static PFNRESETHISTOGRAMEXTPROC_HPP fn=reinterpret_cast<PFNRESETHISTOGRAMEXTPROC_HPP>(_impl::_get_proc_address("glResetHistogramEXT","GL_EXT_histogram"));
	 fn(target);
}

typedef void (*PFNRESETMINMAXEXTPROC_HPP)(GLenum target);

static inline void ResetMinmaxEXT(GLenum target)
{
	static PFNRESETMINMAXEXTPROC_HPP fn=reinterpret_cast<PFNRESETMINMAXEXTPROC_HPP>(_impl::_get_proc_address("glResetMinmaxEXT","GL_EXT_histogram"));
	 fn(target);
}
#ifndef GL_EXT_index_array_formats

#define GL_EXT_index_array_formats
#ifndef GL_IUI_V2F_EXT
#define GL_IUI_V2F_EXT                                                  0x81AD
#endif //GL_IUI_V2F_EXT
#ifndef GL_IUI_V3F_EXT
#define GL_IUI_V3F_EXT                                                  0x81AE
#endif //GL_IUI_V3F_EXT
#ifndef GL_IUI_N3F_V2F_EXT
#define GL_IUI_N3F_V2F_EXT                                              0x81AF
#endif //GL_IUI_N3F_V2F_EXT
#ifndef GL_IUI_N3F_V3F_EXT
#define GL_IUI_N3F_V3F_EXT                                              0x81B0
#endif //GL_IUI_N3F_V3F_EXT
#ifndef GL_T2F_IUI_V2F_EXT
#define GL_T2F_IUI_V2F_EXT                                              0x81B1
#endif //GL_T2F_IUI_V2F_EXT
#ifndef GL_T2F_IUI_V3F_EXT
#define GL_T2F_IUI_V3F_EXT                                              0x81B2
#endif //GL_T2F_IUI_V3F_EXT
#ifndef GL_T2F_IUI_N3F_V2F_EXT
#define GL_T2F_IUI_N3F_V2F_EXT                                          0x81B3
#endif //GL_T2F_IUI_N3F_V2F_EXT
#ifndef GL_T2F_IUI_N3F_V3F_EXT
#define GL_T2F_IUI_N3F_V3F_EXT                                          0x81B4
#endif //GL_T2F_IUI_N3F_V3F_EXT

#endif //GL_EXT_index_array_formats

#ifndef GL_EXT_index_func

#define GL_EXT_index_func
#ifndef GL_INDEX_TEST_EXT
#define GL_INDEX_TEST_EXT                                               0x81B5
#endif //GL_INDEX_TEST_EXT
#ifndef GL_INDEX_TEST_FUNC_EXT
#define GL_INDEX_TEST_FUNC_EXT                                          0x81B6
#endif //GL_INDEX_TEST_FUNC_EXT
#ifndef GL_INDEX_TEST_REF_EXT
#define GL_INDEX_TEST_REF_EXT                                           0x81B7
#endif //GL_INDEX_TEST_REF_EXT

#endif //GL_EXT_index_func


typedef void (*PFNINDEXFUNCEXTPROC_HPP)(GLenum func,GLclampf ref);

static inline void IndexFuncEXT(GLenum func,GLclampf ref)
{
	static PFNINDEXFUNCEXTPROC_HPP fn=reinterpret_cast<PFNINDEXFUNCEXTPROC_HPP>(_impl::_get_proc_address("glIndexFuncEXT","GL_EXT_index_func"));
	 fn(func,ref);
}
#ifndef GL_EXT_index_material

#define GL_EXT_index_material
#ifndef GL_INDEX_MATERIAL_EXT
#define GL_INDEX_MATERIAL_EXT                                           0x81B8
#endif //GL_INDEX_MATERIAL_EXT
#ifndef GL_INDEX_MATERIAL_PARAMETER_EXT
#define GL_INDEX_MATERIAL_PARAMETER_EXT                                 0x81B9
#endif //GL_INDEX_MATERIAL_PARAMETER_EXT
#ifndef GL_INDEX_MATERIAL_FACE_EXT
#define GL_INDEX_MATERIAL_FACE_EXT                                      0x81BA
#endif //GL_INDEX_MATERIAL_FACE_EXT

#endif //GL_EXT_index_material


typedef void (*PFNINDEXMATERIALEXTPROC_HPP)(GLenum face,GLenum mode);

static inline void IndexMaterialEXT(GLenum face,GLenum mode)
{
	static PFNINDEXMATERIALEXTPROC_HPP fn=reinterpret_cast<PFNINDEXMATERIALEXTPROC_HPP>(_impl::_get_proc_address("glIndexMaterialEXT","GL_EXT_index_material"));
	 fn(face,mode);
}
#ifndef GL_EXT_light_texture

#define GL_EXT_light_texture
#ifndef GL_FRAGMENT_MATERIAL_EXT
#define GL_FRAGMENT_MATERIAL_EXT                                        0x8349
#endif //GL_FRAGMENT_MATERIAL_EXT
#ifndef GL_FRAGMENT_NORMAL_EXT
#define GL_FRAGMENT_NORMAL_EXT                                          0x834A
#endif //GL_FRAGMENT_NORMAL_EXT
#ifndef GL_FRAGMENT_COLOR_EXT
#define GL_FRAGMENT_COLOR_EXT                                           0x834C
#endif //GL_FRAGMENT_COLOR_EXT
#ifndef GL_ATTENUATION_EXT
#define GL_ATTENUATION_EXT                                              0x834D
#endif //GL_ATTENUATION_EXT
#ifndef GL_SHADOW_ATTENUATION_EXT
#define GL_SHADOW_ATTENUATION_EXT                                       0x834E
#endif //GL_SHADOW_ATTENUATION_EXT
#ifndef GL_TEXTURE_APPLICATION_MODE_EXT
#define GL_TEXTURE_APPLICATION_MODE_EXT                                 0x834F
#endif //GL_TEXTURE_APPLICATION_MODE_EXT
#ifndef GL_TEXTURE_LIGHT_EXT
#define GL_TEXTURE_LIGHT_EXT                                            0x8350
#endif //GL_TEXTURE_LIGHT_EXT
#ifndef GL_TEXTURE_MATERIAL_FACE_EXT
#define GL_TEXTURE_MATERIAL_FACE_EXT                                    0x8351
#endif //GL_TEXTURE_MATERIAL_FACE_EXT
#ifndef GL_TEXTURE_MATERIAL_PARAMETER_EXT
#define GL_TEXTURE_MATERIAL_PARAMETER_EXT                               0x8352
#endif //GL_TEXTURE_MATERIAL_PARAMETER_EXT

#endif //GL_EXT_light_texture


typedef void (*PFNAPPLYTEXTUREEXTPROC_HPP)(GLenum mode);

static inline void ApplyTextureEXT(GLenum mode)
{
	static PFNAPPLYTEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNAPPLYTEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glApplyTextureEXT","GL_EXT_light_texture"));
	 fn(mode);
}

typedef void (*PFNTEXTURELIGHTEXTPROC_HPP)(GLenum pname);

static inline void TextureLightEXT(GLenum pname)
{
	static PFNTEXTURELIGHTEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURELIGHTEXTPROC_HPP>(_impl::_get_proc_address("glTextureLightEXT","GL_EXT_light_texture"));
	 fn(pname);
}

typedef void (*PFNTEXTUREMATERIALEXTPROC_HPP)(GLenum face,GLenum mode);

static inline void TextureMaterialEXT(GLenum face,GLenum mode)
{
	static PFNTEXTUREMATERIALEXTPROC_HPP fn=reinterpret_cast<PFNTEXTUREMATERIALEXTPROC_HPP>(_impl::_get_proc_address("glTextureMaterialEXT","GL_EXT_light_texture"));
	 fn(face,mode);
}
#ifndef GL_EXT_map_buffer_range

#define GL_EXT_map_buffer_range
#ifndef GL_MAP_READ_BIT_EXT
#define GL_MAP_READ_BIT_EXT                                             0x0001
#endif //GL_MAP_READ_BIT_EXT
#ifndef GL_MAP_WRITE_BIT_EXT
#define GL_MAP_WRITE_BIT_EXT                                            0x0002
#endif //GL_MAP_WRITE_BIT_EXT
#ifndef GL_MAP_INVALIDATE_RANGE_BIT_EXT
#define GL_MAP_INVALIDATE_RANGE_BIT_EXT                                 0x0004
#endif //GL_MAP_INVALIDATE_RANGE_BIT_EXT
#ifndef GL_MAP_INVALIDATE_BUFFER_BIT_EXT
#define GL_MAP_INVALIDATE_BUFFER_BIT_EXT                                0x0008
#endif //GL_MAP_INVALIDATE_BUFFER_BIT_EXT
#ifndef GL_MAP_FLUSH_EXPLICIT_BIT_EXT
#define GL_MAP_FLUSH_EXPLICIT_BIT_EXT                                   0x0010
#endif //GL_MAP_FLUSH_EXPLICIT_BIT_EXT
#ifndef GL_MAP_UNSYNCHRONIZED_BIT_EXT
#define GL_MAP_UNSYNCHRONIZED_BIT_EXT                                   0x0020
#endif //GL_MAP_UNSYNCHRONIZED_BIT_EXT

#endif //GL_EXT_map_buffer_range

#ifndef GL_EXT_multi_draw_arrays

#define GL_EXT_multi_draw_arrays

#endif //GL_EXT_multi_draw_arrays


typedef void (*PFNMULTIDRAWARRAYSEXTPROC_HPP)(GLenum mode,const GLint *first,const GLsizei *count,GLsizei primcount);

static inline void MultiDrawArraysEXT(GLenum mode,const GLint *first,const GLsizei *count,GLsizei primcount)
{
	static PFNMULTIDRAWARRAYSEXTPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWARRAYSEXTPROC_HPP>(_impl::_get_proc_address("glMultiDrawArraysEXT","GL_EXT_multi_draw_arrays"));
	 fn(mode,first,count,primcount);
}

typedef void (*PFNMULTIDRAWELEMENTSEXTPROC_HPP)(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* *indices,GLsizei primcount);

static inline void MultiDrawElementsEXT(GLenum mode,const GLsizei *count,GLenum type,const GLvoid* *indices,GLsizei primcount)
{
	static PFNMULTIDRAWELEMENTSEXTPROC_HPP fn=reinterpret_cast<PFNMULTIDRAWELEMENTSEXTPROC_HPP>(_impl::_get_proc_address("glMultiDrawElementsEXT","GL_EXT_multi_draw_arrays"));
	 fn(mode,count,type,indices,primcount);
}
#ifndef GL_EXT_multisample

#define GL_EXT_multisample
#ifndef GL_MULTISAMPLE_BIT_EXT
#define GL_MULTISAMPLE_BIT_EXT                                          0x20000000
#endif //GL_MULTISAMPLE_BIT_EXT
#ifndef GL_MULTISAMPLE_EXT
#define GL_MULTISAMPLE_EXT                                              0x809D
#endif //GL_MULTISAMPLE_EXT
#ifndef GL_SAMPLE_ALPHA_TO_MASK_EXT
#define GL_SAMPLE_ALPHA_TO_MASK_EXT                                     0x809E
#endif //GL_SAMPLE_ALPHA_TO_MASK_EXT
#ifndef GL_SAMPLE_ALPHA_TO_ONE_EXT
#define GL_SAMPLE_ALPHA_TO_ONE_EXT                                      0x809F
#endif //GL_SAMPLE_ALPHA_TO_ONE_EXT
#ifndef GL_SAMPLE_MASK_EXT
#define GL_SAMPLE_MASK_EXT                                              0x80A0
#endif //GL_SAMPLE_MASK_EXT
#ifndef GL_1PASS_EXT
#define GL_1PASS_EXT                                                    0x80A1
#endif //GL_1PASS_EXT
#ifndef GL_2PASS_0_EXT
#define GL_2PASS_0_EXT                                                  0x80A2
#endif //GL_2PASS_0_EXT
#ifndef GL_2PASS_1_EXT
#define GL_2PASS_1_EXT                                                  0x80A3
#endif //GL_2PASS_1_EXT
#ifndef GL_4PASS_0_EXT
#define GL_4PASS_0_EXT                                                  0x80A4
#endif //GL_4PASS_0_EXT
#ifndef GL_4PASS_1_EXT
#define GL_4PASS_1_EXT                                                  0x80A5
#endif //GL_4PASS_1_EXT
#ifndef GL_4PASS_2_EXT
#define GL_4PASS_2_EXT                                                  0x80A6
#endif //GL_4PASS_2_EXT
#ifndef GL_4PASS_3_EXT
#define GL_4PASS_3_EXT                                                  0x80A7
#endif //GL_4PASS_3_EXT
#ifndef GL_SAMPLE_BUFFERS_EXT
#define GL_SAMPLE_BUFFERS_EXT                                           0x80A8
#endif //GL_SAMPLE_BUFFERS_EXT
#ifndef GL_SAMPLES_EXT
#define GL_SAMPLES_EXT                                                  0x80A9
#endif //GL_SAMPLES_EXT
#ifndef GL_SAMPLE_MASK_VALUE_EXT
#define GL_SAMPLE_MASK_VALUE_EXT                                        0x80AA
#endif //GL_SAMPLE_MASK_VALUE_EXT
#ifndef GL_SAMPLE_MASK_INVERT_EXT
#define GL_SAMPLE_MASK_INVERT_EXT                                       0x80AB
#endif //GL_SAMPLE_MASK_INVERT_EXT
#ifndef GL_SAMPLE_PATTERN_EXT
#define GL_SAMPLE_PATTERN_EXT                                           0x80AC
#endif //GL_SAMPLE_PATTERN_EXT

#endif //GL_EXT_multisample


typedef void (*PFNSAMPLEMASKEXTPROC_HPP)(GLclampf value,GLboolean invert);

static inline void SampleMaskEXT(GLclampf value,GLboolean invert)
{
	static PFNSAMPLEMASKEXTPROC_HPP fn=reinterpret_cast<PFNSAMPLEMASKEXTPROC_HPP>(_impl::_get_proc_address("glSampleMaskEXT","GL_EXT_multisample"));
	 fn(value,invert);
}

typedef void (*PFNSAMPLEPATTERNEXTPROC_HPP)(GLenum pattern);

static inline void SamplePatternEXT(GLenum pattern)
{
	static PFNSAMPLEPATTERNEXTPROC_HPP fn=reinterpret_cast<PFNSAMPLEPATTERNEXTPROC_HPP>(_impl::_get_proc_address("glSamplePatternEXT","GL_EXT_multisample"));
	 fn(pattern);
}
#ifndef GL_EXT_multisampled_render_to_texture

#define GL_EXT_multisampled_render_to_texture
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT                   0x8D6C
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT

#endif //GL_EXT_multisampled_render_to_texture

#ifndef GL_EXT_multiview_draw_buffers

#define GL_EXT_multiview_draw_buffers
#ifndef GL_DRAW_BUFFER_EXT
#define GL_DRAW_BUFFER_EXT                                              0x0C01
#endif //GL_DRAW_BUFFER_EXT
#ifndef GL_READ_BUFFER_EXT
#define GL_READ_BUFFER_EXT                                              0x0C02
#endif //GL_READ_BUFFER_EXT
#ifndef GL_COLOR_ATTACHMENT_EXT
#define GL_COLOR_ATTACHMENT_EXT                                         0x90F0
#endif //GL_COLOR_ATTACHMENT_EXT
#ifndef GL_MULTIVIEW_EXT
#define GL_MULTIVIEW_EXT                                                0x90F1
#endif //GL_MULTIVIEW_EXT
#ifndef GL_MAX_MULTIVIEW_BUFFERS_EXT
#define GL_MAX_MULTIVIEW_BUFFERS_EXT                                    0x90F2
#endif //GL_MAX_MULTIVIEW_BUFFERS_EXT

#endif //GL_EXT_multiview_draw_buffers

#ifndef GL_EXT_occlusion_query_boolean

#define GL_EXT_occlusion_query_boolean
#ifndef GL_CURRENT_QUERY_EXT
#define GL_CURRENT_QUERY_EXT                                            0x8865
#endif //GL_CURRENT_QUERY_EXT
#ifndef GL_QUERY_RESULT_EXT
#define GL_QUERY_RESULT_EXT                                             0x8866
#endif //GL_QUERY_RESULT_EXT
#ifndef GL_QUERY_RESULT_AVAILABLE_EXT
#define GL_QUERY_RESULT_AVAILABLE_EXT                                   0x8867
#endif //GL_QUERY_RESULT_AVAILABLE_EXT
#ifndef GL_ANY_SAMPLES_PASSED_EXT
#define GL_ANY_SAMPLES_PASSED_EXT                                       0x8C2F
#endif //GL_ANY_SAMPLES_PASSED_EXT
#ifndef GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT
#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT                          0x8D6A
#endif //GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT

#endif //GL_EXT_occlusion_query_boolean

#ifndef GL_EXT_packed_depth_stencil

#define GL_EXT_packed_depth_stencil
#ifndef GL_DEPTH_STENCIL_EXT
#define GL_DEPTH_STENCIL_EXT                                            0x84F9
#endif //GL_DEPTH_STENCIL_EXT
#ifndef GL_UNSIGNED_INT_24_8_EXT
#define GL_UNSIGNED_INT_24_8_EXT                                        0x84FA
#endif //GL_UNSIGNED_INT_24_8_EXT
#ifndef GL_DEPTH24_STENCIL8_EXT
#define GL_DEPTH24_STENCIL8_EXT                                         0x88F0
#endif //GL_DEPTH24_STENCIL8_EXT
#ifndef GL_TEXTURE_STENCIL_SIZE_EXT
#define GL_TEXTURE_STENCIL_SIZE_EXT                                     0x88F1
#endif //GL_TEXTURE_STENCIL_SIZE_EXT

#endif //GL_EXT_packed_depth_stencil

#ifndef GL_EXT_packed_float

#define GL_EXT_packed_float
#ifndef GL_R11F_G11F_B10F_EXT
#define GL_R11F_G11F_B10F_EXT                                           0x8C3A
#endif //GL_R11F_G11F_B10F_EXT
#ifndef GL_UNSIGNED_INT_10F_11F_11F_REV_EXT
#define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT                             0x8C3B
#endif //GL_UNSIGNED_INT_10F_11F_11F_REV_EXT
#ifndef GL_RGBA_SIGNED_COMPONENTS_EXT
#define GL_RGBA_SIGNED_COMPONENTS_EXT                                   0x8C3C
#endif //GL_RGBA_SIGNED_COMPONENTS_EXT

#endif //GL_EXT_packed_float

#ifndef GL_EXT_packed_pixels

#define GL_EXT_packed_pixels
#ifndef GL_UNSIGNED_BYTE_3_3_2_EXT
#define GL_UNSIGNED_BYTE_3_3_2_EXT                                      0x8032
#endif //GL_UNSIGNED_BYTE_3_3_2_EXT
#ifndef GL_UNSIGNED_SHORT_4_4_4_4_EXT
#define GL_UNSIGNED_SHORT_4_4_4_4_EXT                                   0x8033
#endif //GL_UNSIGNED_SHORT_4_4_4_4_EXT
#ifndef GL_UNSIGNED_SHORT_5_5_5_1_EXT
#define GL_UNSIGNED_SHORT_5_5_5_1_EXT                                   0x8034
#endif //GL_UNSIGNED_SHORT_5_5_5_1_EXT
#ifndef GL_UNSIGNED_INT_8_8_8_8_EXT
#define GL_UNSIGNED_INT_8_8_8_8_EXT                                     0x8035
#endif //GL_UNSIGNED_INT_8_8_8_8_EXT
#ifndef GL_UNSIGNED_INT_10_10_10_2_EXT
#define GL_UNSIGNED_INT_10_10_10_2_EXT                                  0x8036
#endif //GL_UNSIGNED_INT_10_10_10_2_EXT
#ifndef GL_UNSIGNED_BYTE_2_3_3_REV_EXT
#define GL_UNSIGNED_BYTE_2_3_3_REV_EXT                                  0x8362
#endif //GL_UNSIGNED_BYTE_2_3_3_REV_EXT
#ifndef GL_UNSIGNED_SHORT_5_6_5_EXT
#define GL_UNSIGNED_SHORT_5_6_5_EXT                                     0x8363
#endif //GL_UNSIGNED_SHORT_5_6_5_EXT
#ifndef GL_UNSIGNED_SHORT_5_6_5_REV_EXT
#define GL_UNSIGNED_SHORT_5_6_5_REV_EXT                                 0x8364
#endif //GL_UNSIGNED_SHORT_5_6_5_REV_EXT
#ifndef GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT
#define GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT                               0x8365
#endif //GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT
#ifndef GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT
#define GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT                               0x8366
#endif //GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT
#ifndef GL_UNSIGNED_INT_8_8_8_8_REV_EXT
#define GL_UNSIGNED_INT_8_8_8_8_REV_EXT                                 0x8367
#endif //GL_UNSIGNED_INT_8_8_8_8_REV_EXT
#ifndef GL_UNSIGNED_INT_2_10_10_10_REV_EXT
#define GL_UNSIGNED_INT_2_10_10_10_REV_EXT                              0x8368
#endif //GL_UNSIGNED_INT_2_10_10_10_REV_EXT

#endif //GL_EXT_packed_pixels

#ifndef GL_EXT_paletted_texture

#define GL_EXT_paletted_texture

#endif //GL_EXT_paletted_texture


typedef void (*PFNCOLORTABLEEXTPROC_HPP)(GLenum target,GLenum internalFormat,GLsizei width,GLenum format,GLenum type,const GLvoid *table);

static inline void ColorTableEXT(GLenum target,GLenum internalFormat,GLsizei width,GLenum format,GLenum type,const GLvoid *table)
{
	static PFNCOLORTABLEEXTPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEEXTPROC_HPP>(_impl::_get_proc_address("glColorTableEXT","GL_EXT_paletted_texture"));
	 fn(target,internalFormat,width,format,type,table);
}

typedef void (*PFNGETCOLORTABLEEXTPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *data);

static inline void GetColorTableEXT(GLenum target,GLenum format,GLenum type,GLvoid *data)
{
	static PFNGETCOLORTABLEEXTPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEEXTPROC_HPP>(_impl::_get_proc_address("glGetColorTableEXT","GL_EXT_paletted_texture"));
	 fn(target,format,type,data);
}

typedef void (*PFNGETCOLORTABLEPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetColorTableParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETCOLORTABLEPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameterivEXT","GL_EXT_paletted_texture"));
	 fn(target,pname,params);
}

typedef void (*PFNGETCOLORTABLEPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetColorTableParameterfvEXT(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETCOLORTABLEPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameterfvEXT","GL_EXT_paletted_texture"));
	 fn(target,pname,params);
}
#ifndef GL_EXT_pixel_buffer_object

#define GL_EXT_pixel_buffer_object
#ifndef GL_PIXEL_PACK_BUFFER_EXT
#define GL_PIXEL_PACK_BUFFER_EXT                                        0x88EB
#endif //GL_PIXEL_PACK_BUFFER_EXT
#ifndef GL_PIXEL_UNPACK_BUFFER_EXT
#define GL_PIXEL_UNPACK_BUFFER_EXT                                      0x88EC
#endif //GL_PIXEL_UNPACK_BUFFER_EXT
#ifndef GL_PIXEL_PACK_BUFFER_BINDING_EXT
#define GL_PIXEL_PACK_BUFFER_BINDING_EXT                                0x88ED
#endif //GL_PIXEL_PACK_BUFFER_BINDING_EXT
#ifndef GL_PIXEL_UNPACK_BUFFER_BINDING_EXT
#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT                              0x88EF
#endif //GL_PIXEL_UNPACK_BUFFER_BINDING_EXT

#endif //GL_EXT_pixel_buffer_object

#ifndef GL_EXT_pixel_transform

#define GL_EXT_pixel_transform
#ifndef GL_PIXEL_TRANSFORM_2D_EXT
#define GL_PIXEL_TRANSFORM_2D_EXT                                       0x8330
#endif //GL_PIXEL_TRANSFORM_2D_EXT
#ifndef GL_PIXEL_MAG_FILTER_EXT
#define GL_PIXEL_MAG_FILTER_EXT                                         0x8331
#endif //GL_PIXEL_MAG_FILTER_EXT
#ifndef GL_PIXEL_MIN_FILTER_EXT
#define GL_PIXEL_MIN_FILTER_EXT                                         0x8332
#endif //GL_PIXEL_MIN_FILTER_EXT
#ifndef GL_PIXEL_CUBIC_WEIGHT_EXT
#define GL_PIXEL_CUBIC_WEIGHT_EXT                                       0x8333
#endif //GL_PIXEL_CUBIC_WEIGHT_EXT
#ifndef GL_CUBIC_EXT
#define GL_CUBIC_EXT                                                    0x8334
#endif //GL_CUBIC_EXT
#ifndef GL_AVERAGE_EXT
#define GL_AVERAGE_EXT                                                  0x8335
#endif //GL_AVERAGE_EXT
#ifndef GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT                           0x8336
#endif //GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
#ifndef GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT                       0x8337
#endif //GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT
#ifndef GL_PIXEL_TRANSFORM_2D_MATRIX_EXT
#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT                                0x8338
#endif //GL_PIXEL_TRANSFORM_2D_MATRIX_EXT

#endif //GL_EXT_pixel_transform


typedef void (*PFNPIXELTRANSFORMPARAMETERIEXTPROC_HPP)(GLenum target,GLenum pname,GLint param);

static inline void PixelTransformParameteriEXT(GLenum target,GLenum pname,GLint param)
{
	static PFNPIXELTRANSFORMPARAMETERIEXTPROC_HPP fn=reinterpret_cast<PFNPIXELTRANSFORMPARAMETERIEXTPROC_HPP>(_impl::_get_proc_address("glPixelTransformParameteriEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,param);
}

typedef void (*PFNPIXELTRANSFORMPARAMETERFEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat param);

static inline void PixelTransformParameterfEXT(GLenum target,GLenum pname,GLfloat param)
{
	static PFNPIXELTRANSFORMPARAMETERFEXTPROC_HPP fn=reinterpret_cast<PFNPIXELTRANSFORMPARAMETERFEXTPROC_HPP>(_impl::_get_proc_address("glPixelTransformParameterfEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,param);
}

typedef void (*PFNPIXELTRANSFORMPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void PixelTransformParameterivEXT(GLenum target,GLenum pname,const GLint *params)
{
	static PFNPIXELTRANSFORMPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNPIXELTRANSFORMPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glPixelTransformParameterivEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNPIXELTRANSFORMPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void PixelTransformParameterfvEXT(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNPIXELTRANSFORMPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNPIXELTRANSFORMPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glPixelTransformParameterfvEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNGETPIXELTRANSFORMPARAMETERIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetPixelTransformParameterivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETPIXELTRANSFORMPARAMETERIVEXTPROC_HPP fn=reinterpret_cast<PFNGETPIXELTRANSFORMPARAMETERIVEXTPROC_HPP>(_impl::_get_proc_address("glGetPixelTransformParameterivEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNGETPIXELTRANSFORMPARAMETERFVEXTPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetPixelTransformParameterfvEXT(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETPIXELTRANSFORMPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNGETPIXELTRANSFORMPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glGetPixelTransformParameterfvEXT","GL_EXT_pixel_transform"));
	 fn(target,pname,params);
}
#ifndef GL_EXT_point_parameters

#define GL_EXT_point_parameters
#ifndef GL_POINT_SIZE_MIN_EXT
#define GL_POINT_SIZE_MIN_EXT                                           0x8126
#endif //GL_POINT_SIZE_MIN_EXT
#ifndef GL_POINT_SIZE_MAX_EXT
#define GL_POINT_SIZE_MAX_EXT                                           0x8127
#endif //GL_POINT_SIZE_MAX_EXT
#ifndef GL_POINT_FADE_THRESHOLD_SIZE_EXT
#define GL_POINT_FADE_THRESHOLD_SIZE_EXT                                0x8128
#endif //GL_POINT_FADE_THRESHOLD_SIZE_EXT
#ifndef GL_DISTANCE_ATTENUATION_EXT
#define GL_DISTANCE_ATTENUATION_EXT                                     0x8129
#endif //GL_DISTANCE_ATTENUATION_EXT

#endif //GL_EXT_point_parameters


typedef void (*PFNPOINTPARAMETERFEXTPROC_HPP)(GLenum pname,GLfloat param);

static inline void PointParameterfEXT(GLenum pname,GLfloat param)
{
	static PFNPOINTPARAMETERFEXTPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFEXTPROC_HPP>(_impl::_get_proc_address("glPointParameterfEXT","GL_EXT_point_parameters"));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERFVEXTPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void PointParameterfvEXT(GLenum pname,const GLfloat *params)
{
	static PFNPOINTPARAMETERFVEXTPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFVEXTPROC_HPP>(_impl::_get_proc_address("glPointParameterfvEXT","GL_EXT_point_parameters"));
	 fn(pname,params);
}
#ifndef GL_EXT_polygon_offset

#define GL_EXT_polygon_offset
#ifndef GL_POLYGON_OFFSET_EXT
#define GL_POLYGON_OFFSET_EXT                                           0x8037
#endif //GL_POLYGON_OFFSET_EXT
#ifndef GL_POLYGON_OFFSET_FACTOR_EXT
#define GL_POLYGON_OFFSET_FACTOR_EXT                                    0x8038
#endif //GL_POLYGON_OFFSET_FACTOR_EXT
#ifndef GL_POLYGON_OFFSET_BIAS_EXT
#define GL_POLYGON_OFFSET_BIAS_EXT                                      0x8039
#endif //GL_POLYGON_OFFSET_BIAS_EXT

#endif //GL_EXT_polygon_offset


typedef void (*PFNPOLYGONOFFSETEXTPROC_HPP)(GLfloat factor,GLfloat bias);

static inline void PolygonOffsetEXT(GLfloat factor,GLfloat bias)
{
	static PFNPOLYGONOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNPOLYGONOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glPolygonOffsetEXT","GL_EXT_polygon_offset"));
	 fn(factor,bias);
}
#ifndef GL_EXT_provoking_vertex

#define GL_EXT_provoking_vertex
#ifndef GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT
#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT                 0x8E4C
#endif //GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT
#ifndef GL_FIRST_VERTEX_CONVENTION_EXT
#define GL_FIRST_VERTEX_CONVENTION_EXT                                  0x8E4D
#endif //GL_FIRST_VERTEX_CONVENTION_EXT
#ifndef GL_LAST_VERTEX_CONVENTION_EXT
#define GL_LAST_VERTEX_CONVENTION_EXT                                   0x8E4E
#endif //GL_LAST_VERTEX_CONVENTION_EXT
#ifndef GL_PROVOKING_VERTEX_EXT
#define GL_PROVOKING_VERTEX_EXT                                         0x8E4F
#endif //GL_PROVOKING_VERTEX_EXT

#endif //GL_EXT_provoking_vertex


typedef void (*PFNPROVOKINGVERTEXEXTPROC_HPP)(GLenum mode);

static inline void ProvokingVertexEXT(GLenum mode)
{
	static PFNPROVOKINGVERTEXEXTPROC_HPP fn=reinterpret_cast<PFNPROVOKINGVERTEXEXTPROC_HPP>(_impl::_get_proc_address("glProvokingVertexEXT","GL_EXT_provoking_vertex"));
	 fn(mode);
}
#ifndef GL_EXT_rescale_normal

#define GL_EXT_rescale_normal
#ifndef GL_RESCALE_NORMAL_EXT
#define GL_RESCALE_NORMAL_EXT                                           0x803A
#endif //GL_RESCALE_NORMAL_EXT

#endif //GL_EXT_rescale_normal

#ifndef GL_EXT_secondary_color

#define GL_EXT_secondary_color
#ifndef GL_COLOR_SUM_EXT
#define GL_COLOR_SUM_EXT                                                0x8458
#endif //GL_COLOR_SUM_EXT
#ifndef GL_CURRENT_SECONDARY_COLOR_EXT
#define GL_CURRENT_SECONDARY_COLOR_EXT                                  0x8459
#endif //GL_CURRENT_SECONDARY_COLOR_EXT
#ifndef GL_SECONDARY_COLOR_ARRAY_SIZE_EXT
#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT                               0x845A
#endif //GL_SECONDARY_COLOR_ARRAY_SIZE_EXT
#ifndef GL_SECONDARY_COLOR_ARRAY_TYPE_EXT
#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT                               0x845B
#endif //GL_SECONDARY_COLOR_ARRAY_TYPE_EXT
#ifndef GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT
#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT                             0x845C
#endif //GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT
#ifndef GL_SECONDARY_COLOR_ARRAY_POINTER_EXT
#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT                            0x845D
#endif //GL_SECONDARY_COLOR_ARRAY_POINTER_EXT
#ifndef GL_SECONDARY_COLOR_ARRAY_EXT
#define GL_SECONDARY_COLOR_ARRAY_EXT                                    0x845E
#endif //GL_SECONDARY_COLOR_ARRAY_EXT

#endif //GL_EXT_secondary_color


typedef void (*PFNSECONDARYCOLOR3BEXTPROC_HPP)(GLbyte red,GLbyte green,GLbyte blue);

static inline void SecondaryColor3bEXT(GLbyte red,GLbyte green,GLbyte blue)
{
	static PFNSECONDARYCOLOR3BEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3BEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3bEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3BVEXTPROC_HPP)(const GLbyte *v);

static inline void SecondaryColor3bvEXT(const GLbyte *v)
{
	static PFNSECONDARYCOLOR3BVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3BVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3bvEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3DEXTPROC_HPP)(GLdouble red,GLdouble green,GLdouble blue);

static inline void SecondaryColor3dEXT(GLdouble red,GLdouble green,GLdouble blue)
{
	static PFNSECONDARYCOLOR3DEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3DEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3dEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3DVEXTPROC_HPP)(const GLdouble *v);

static inline void SecondaryColor3dvEXT(const GLdouble *v)
{
	static PFNSECONDARYCOLOR3DVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3DVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3dvEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3FEXTPROC_HPP)(GLfloat red,GLfloat green,GLfloat blue);

static inline void SecondaryColor3fEXT(GLfloat red,GLfloat green,GLfloat blue)
{
	static PFNSECONDARYCOLOR3FEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3FEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3fEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3FVEXTPROC_HPP)(const GLfloat *v);

static inline void SecondaryColor3fvEXT(const GLfloat *v)
{
	static PFNSECONDARYCOLOR3FVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3FVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3fvEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3IEXTPROC_HPP)(GLint red,GLint green,GLint blue);

static inline void SecondaryColor3iEXT(GLint red,GLint green,GLint blue)
{
	static PFNSECONDARYCOLOR3IEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3IEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3iEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3IVEXTPROC_HPP)(const GLint *v);

static inline void SecondaryColor3ivEXT(const GLint *v)
{
	static PFNSECONDARYCOLOR3IVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3IVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ivEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3SEXTPROC_HPP)(GLshort red,GLshort green,GLshort blue);

static inline void SecondaryColor3sEXT(GLshort red,GLshort green,GLshort blue)
{
	static PFNSECONDARYCOLOR3SEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3SEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3sEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3SVEXTPROC_HPP)(const GLshort *v);

static inline void SecondaryColor3svEXT(const GLshort *v)
{
	static PFNSECONDARYCOLOR3SVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3SVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3svEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3UBEXTPROC_HPP)(GLubyte red,GLubyte green,GLubyte blue);

static inline void SecondaryColor3ubEXT(GLubyte red,GLubyte green,GLubyte blue)
{
	static PFNSECONDARYCOLOR3UBEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UBEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ubEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3UBVEXTPROC_HPP)(const GLubyte *v);

static inline void SecondaryColor3ubvEXT(const GLubyte *v)
{
	static PFNSECONDARYCOLOR3UBVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UBVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3ubvEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3UIEXTPROC_HPP)(GLuint red,GLuint green,GLuint blue);

static inline void SecondaryColor3uiEXT(GLuint red,GLuint green,GLuint blue)
{
	static PFNSECONDARYCOLOR3UIEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UIEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3uiEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3UIVEXTPROC_HPP)(const GLuint *v);

static inline void SecondaryColor3uivEXT(const GLuint *v)
{
	static PFNSECONDARYCOLOR3UIVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3UIVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3uivEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLOR3USEXTPROC_HPP)(GLushort red,GLushort green,GLushort blue);

static inline void SecondaryColor3usEXT(GLushort red,GLushort green,GLushort blue)
{
	static PFNSECONDARYCOLOR3USEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3USEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3usEXT","GL_EXT_secondary_color"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3USVEXTPROC_HPP)(const GLushort *v);

static inline void SecondaryColor3usvEXT(const GLushort *v)
{
	static PFNSECONDARYCOLOR3USVEXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3USVEXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3usvEXT","GL_EXT_secondary_color"));
	 fn(v);
}

typedef void (*PFNSECONDARYCOLORPOINTEREXTPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void SecondaryColorPointerEXT(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNSECONDARYCOLORPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glSecondaryColorPointerEXT","GL_EXT_secondary_color"));
	 fn(size,type,stride,pointer);
}
#ifndef GL_EXT_separate_shader_objects

#define GL_EXT_separate_shader_objects
#ifndef GL_VERTEX_SHADER_BIT_EXT
#define GL_VERTEX_SHADER_BIT_EXT                                        0x00000001
#endif //GL_VERTEX_SHADER_BIT_EXT
#ifndef GL_FRAGMENT_SHADER_BIT_EXT
#define GL_FRAGMENT_SHADER_BIT_EXT                                      0x00000002
#endif //GL_FRAGMENT_SHADER_BIT_EXT
#ifndef GL_PROGRAM_SEPARABLE_EXT
#define GL_PROGRAM_SEPARABLE_EXT                                        0x8258
#endif //GL_PROGRAM_SEPARABLE_EXT
#ifndef GL_PROGRAM_PIPELINE_BINDING_EXT
#define GL_PROGRAM_PIPELINE_BINDING_EXT                                 0x825A
#endif //GL_PROGRAM_PIPELINE_BINDING_EXT
#ifndef GL_ACTIVE_PROGRAM_EXT
#define GL_ACTIVE_PROGRAM_EXT                                           0x8B8D
#endif //GL_ACTIVE_PROGRAM_EXT
#ifndef GL_ALL_SHADER_BITS_EXT
#define GL_ALL_SHADER_BITS_EXT                                          0xFFFFFFFF
#endif //GL_ALL_SHADER_BITS_EXT

#endif //GL_EXT_separate_shader_objects


typedef void (*PFNUSESHADERPROGRAMEXTPROC_HPP)(GLenum type,GLuint program);

static inline void UseShaderProgramEXT(GLenum type,GLuint program)
{
	static PFNUSESHADERPROGRAMEXTPROC_HPP fn=reinterpret_cast<PFNUSESHADERPROGRAMEXTPROC_HPP>(_impl::_get_proc_address("glUseShaderProgramEXT","GL_EXT_separate_shader_objects"));
	 fn(type,program);
}

typedef void (*PFNACTIVEPROGRAMEXTPROC_HPP)(GLuint program);

static inline void ActiveProgramEXT(GLuint program)
{
	static PFNACTIVEPROGRAMEXTPROC_HPP fn=reinterpret_cast<PFNACTIVEPROGRAMEXTPROC_HPP>(_impl::_get_proc_address("glActiveProgramEXT","GL_EXT_separate_shader_objects"));
	 fn(program);
}

typedef GLuint (*PFNCREATESHADERPROGRAMEXTPROC_HPP)(GLenum type,const GLchar *string);

static inline GLuint CreateShaderProgramEXT(GLenum type,const GLchar *string)
{
	static PFNCREATESHADERPROGRAMEXTPROC_HPP fn=reinterpret_cast<PFNCREATESHADERPROGRAMEXTPROC_HPP>(_impl::_get_proc_address("glCreateShaderProgramEXT","GL_EXT_separate_shader_objects"));
	return fn(type,string);
}
#ifndef GL_EXT_separate_specular_color

#define GL_EXT_separate_specular_color
#ifndef GL_LIGHT_MODEL_COLOR_CONTROL_EXT
#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT                                0x81F8
#endif //GL_LIGHT_MODEL_COLOR_CONTROL_EXT
#ifndef GL_SINGLE_COLOR_EXT
#define GL_SINGLE_COLOR_EXT                                             0x81F9
#endif //GL_SINGLE_COLOR_EXT
#ifndef GL_SEPARATE_SPECULAR_COLOR_EXT
#define GL_SEPARATE_SPECULAR_COLOR_EXT                                  0x81FA
#endif //GL_SEPARATE_SPECULAR_COLOR_EXT

#endif //GL_EXT_separate_specular_color

#ifndef GL_EXT_shader_framebuffer_fetch

#define GL_EXT_shader_framebuffer_fetch
#ifndef GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT
#define GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT                         0x8A52
#endif //GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT

#endif //GL_EXT_shader_framebuffer_fetch

#ifndef GL_EXT_shader_image_load_store

#define GL_EXT_shader_image_load_store
#ifndef GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT
#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT                          0x00000001
#endif //GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT
#ifndef GL_ELEMENT_ARRAY_BARRIER_BIT_EXT
#define GL_ELEMENT_ARRAY_BARRIER_BIT_EXT                                0x00000002
#endif //GL_ELEMENT_ARRAY_BARRIER_BIT_EXT
#ifndef GL_UNIFORM_BARRIER_BIT_EXT
#define GL_UNIFORM_BARRIER_BIT_EXT                                      0x00000004
#endif //GL_UNIFORM_BARRIER_BIT_EXT
#ifndef GL_TEXTURE_FETCH_BARRIER_BIT_EXT
#define GL_TEXTURE_FETCH_BARRIER_BIT_EXT                                0x00000008
#endif //GL_TEXTURE_FETCH_BARRIER_BIT_EXT
#ifndef GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT
#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT                          0x00000020
#endif //GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT
#ifndef GL_COMMAND_BARRIER_BIT_EXT
#define GL_COMMAND_BARRIER_BIT_EXT                                      0x00000040
#endif //GL_COMMAND_BARRIER_BIT_EXT
#ifndef GL_PIXEL_BUFFER_BARRIER_BIT_EXT
#define GL_PIXEL_BUFFER_BARRIER_BIT_EXT                                 0x00000080
#endif //GL_PIXEL_BUFFER_BARRIER_BIT_EXT
#ifndef GL_TEXTURE_UPDATE_BARRIER_BIT_EXT
#define GL_TEXTURE_UPDATE_BARRIER_BIT_EXT                               0x00000100
#endif //GL_TEXTURE_UPDATE_BARRIER_BIT_EXT
#ifndef GL_BUFFER_UPDATE_BARRIER_BIT_EXT
#define GL_BUFFER_UPDATE_BARRIER_BIT_EXT                                0x00000200
#endif //GL_BUFFER_UPDATE_BARRIER_BIT_EXT
#ifndef GL_FRAMEBUFFER_BARRIER_BIT_EXT
#define GL_FRAMEBUFFER_BARRIER_BIT_EXT                                  0x00000400
#endif //GL_FRAMEBUFFER_BARRIER_BIT_EXT
#ifndef GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT
#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT                           0x00000800
#endif //GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT
#ifndef GL_ATOMIC_COUNTER_BARRIER_BIT_EXT
#define GL_ATOMIC_COUNTER_BARRIER_BIT_EXT                               0x00001000
#endif //GL_ATOMIC_COUNTER_BARRIER_BIT_EXT
#ifndef GL_MAX_IMAGE_UNITS_EXT
#define GL_MAX_IMAGE_UNITS_EXT                                          0x8F38
#endif //GL_MAX_IMAGE_UNITS_EXT
#ifndef GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT
#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT            0x8F39
#endif //GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT
#ifndef GL_IMAGE_BINDING_NAME_EXT
#define GL_IMAGE_BINDING_NAME_EXT                                       0x8F3A
#endif //GL_IMAGE_BINDING_NAME_EXT
#ifndef GL_IMAGE_BINDING_LEVEL_EXT
#define GL_IMAGE_BINDING_LEVEL_EXT                                      0x8F3B
#endif //GL_IMAGE_BINDING_LEVEL_EXT
#ifndef GL_IMAGE_BINDING_LAYERED_EXT
#define GL_IMAGE_BINDING_LAYERED_EXT                                    0x8F3C
#endif //GL_IMAGE_BINDING_LAYERED_EXT
#ifndef GL_IMAGE_BINDING_LAYER_EXT
#define GL_IMAGE_BINDING_LAYER_EXT                                      0x8F3D
#endif //GL_IMAGE_BINDING_LAYER_EXT
#ifndef GL_IMAGE_BINDING_ACCESS_EXT
#define GL_IMAGE_BINDING_ACCESS_EXT                                     0x8F3E
#endif //GL_IMAGE_BINDING_ACCESS_EXT
#ifndef GL_IMAGE_1D_EXT
#define GL_IMAGE_1D_EXT                                                 0x904C
#endif //GL_IMAGE_1D_EXT
#ifndef GL_IMAGE_2D_EXT
#define GL_IMAGE_2D_EXT                                                 0x904D
#endif //GL_IMAGE_2D_EXT
#ifndef GL_IMAGE_3D_EXT
#define GL_IMAGE_3D_EXT                                                 0x904E
#endif //GL_IMAGE_3D_EXT
#ifndef GL_IMAGE_2D_RECT_EXT
#define GL_IMAGE_2D_RECT_EXT                                            0x904F
#endif //GL_IMAGE_2D_RECT_EXT
#ifndef GL_IMAGE_CUBE_EXT
#define GL_IMAGE_CUBE_EXT                                               0x9050
#endif //GL_IMAGE_CUBE_EXT
#ifndef GL_IMAGE_BUFFER_EXT
#define GL_IMAGE_BUFFER_EXT                                             0x9051
#endif //GL_IMAGE_BUFFER_EXT
#ifndef GL_IMAGE_1D_ARRAY_EXT
#define GL_IMAGE_1D_ARRAY_EXT                                           0x9052
#endif //GL_IMAGE_1D_ARRAY_EXT
#ifndef GL_IMAGE_2D_ARRAY_EXT
#define GL_IMAGE_2D_ARRAY_EXT                                           0x9053
#endif //GL_IMAGE_2D_ARRAY_EXT
#ifndef GL_IMAGE_CUBE_MAP_ARRAY_EXT
#define GL_IMAGE_CUBE_MAP_ARRAY_EXT                                     0x9054
#endif //GL_IMAGE_CUBE_MAP_ARRAY_EXT
#ifndef GL_IMAGE_2D_MULTISAMPLE_EXT
#define GL_IMAGE_2D_MULTISAMPLE_EXT                                     0x9055
#endif //GL_IMAGE_2D_MULTISAMPLE_EXT
#ifndef GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#define GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT                               0x9056
#endif //GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#ifndef GL_INT_IMAGE_1D_EXT
#define GL_INT_IMAGE_1D_EXT                                             0x9057
#endif //GL_INT_IMAGE_1D_EXT
#ifndef GL_INT_IMAGE_2D_EXT
#define GL_INT_IMAGE_2D_EXT                                             0x9058
#endif //GL_INT_IMAGE_2D_EXT
#ifndef GL_INT_IMAGE_3D_EXT
#define GL_INT_IMAGE_3D_EXT                                             0x9059
#endif //GL_INT_IMAGE_3D_EXT
#ifndef GL_INT_IMAGE_2D_RECT_EXT
#define GL_INT_IMAGE_2D_RECT_EXT                                        0x905A
#endif //GL_INT_IMAGE_2D_RECT_EXT
#ifndef GL_INT_IMAGE_CUBE_EXT
#define GL_INT_IMAGE_CUBE_EXT                                           0x905B
#endif //GL_INT_IMAGE_CUBE_EXT
#ifndef GL_INT_IMAGE_BUFFER_EXT
#define GL_INT_IMAGE_BUFFER_EXT                                         0x905C
#endif //GL_INT_IMAGE_BUFFER_EXT
#ifndef GL_INT_IMAGE_1D_ARRAY_EXT
#define GL_INT_IMAGE_1D_ARRAY_EXT                                       0x905D
#endif //GL_INT_IMAGE_1D_ARRAY_EXT
#ifndef GL_INT_IMAGE_2D_ARRAY_EXT
#define GL_INT_IMAGE_2D_ARRAY_EXT                                       0x905E
#endif //GL_INT_IMAGE_2D_ARRAY_EXT
#ifndef GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT
#define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT                                 0x905F
#endif //GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT
#ifndef GL_INT_IMAGE_2D_MULTISAMPLE_EXT
#define GL_INT_IMAGE_2D_MULTISAMPLE_EXT                                 0x9060
#endif //GL_INT_IMAGE_2D_MULTISAMPLE_EXT
#ifndef GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT                           0x9061
#endif //GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_1D_EXT
#define GL_UNSIGNED_INT_IMAGE_1D_EXT                                    0x9062
#endif //GL_UNSIGNED_INT_IMAGE_1D_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_2D_EXT
#define GL_UNSIGNED_INT_IMAGE_2D_EXT                                    0x9063
#endif //GL_UNSIGNED_INT_IMAGE_2D_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_3D_EXT
#define GL_UNSIGNED_INT_IMAGE_3D_EXT                                    0x9064
#endif //GL_UNSIGNED_INT_IMAGE_3D_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT
#define GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT                               0x9065
#endif //GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_CUBE_EXT
#define GL_UNSIGNED_INT_IMAGE_CUBE_EXT                                  0x9066
#endif //GL_UNSIGNED_INT_IMAGE_CUBE_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_BUFFER_EXT
#define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT                                0x9067
#endif //GL_UNSIGNED_INT_IMAGE_BUFFER_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT
#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT                              0x9068
#endif //GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT
#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT                              0x9069
#endif //GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT
#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT                        0x906A
#endif //GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT                        0x906B
#endif //GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT
#ifndef GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT                  0x906C
#endif //GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT
#ifndef GL_MAX_IMAGE_SAMPLES_EXT
#define GL_MAX_IMAGE_SAMPLES_EXT                                        0x906D
#endif //GL_MAX_IMAGE_SAMPLES_EXT
#ifndef GL_IMAGE_BINDING_FORMAT_EXT
#define GL_IMAGE_BINDING_FORMAT_EXT                                     0x906E
#endif //GL_IMAGE_BINDING_FORMAT_EXT
#ifndef GL_ALL_BARRIER_BITS_EXT
#define GL_ALL_BARRIER_BITS_EXT                                         0xFFFFFFFF
#endif //GL_ALL_BARRIER_BITS_EXT

#endif //GL_EXT_shader_image_load_store


typedef void (*PFNBINDIMAGETEXTUREEXTPROC_HPP)(GLuint index,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLint format);

static inline void BindImageTextureEXT(GLuint index,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLint format)
{
	static PFNBINDIMAGETEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNBINDIMAGETEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glBindImageTextureEXT","GL_EXT_shader_image_load_store"));
	 fn(index,texture,level,layered,layer,access,format);
}

typedef void (*PFNMEMORYBARRIEREXTPROC_HPP)(GLbitfield barriers);

static inline void MemoryBarrierEXT(GLbitfield barriers)
{
	static PFNMEMORYBARRIEREXTPROC_HPP fn=reinterpret_cast<PFNMEMORYBARRIEREXTPROC_HPP>(_impl::_get_proc_address("glMemoryBarrierEXT","GL_EXT_shader_image_load_store"));
	 fn(barriers);
}
#ifndef GL_EXT_shadow_samplers

#define GL_EXT_shadow_samplers
#ifndef GL_TEXTURE_COMPARE_MODE_EXT
#define GL_TEXTURE_COMPARE_MODE_EXT                                     0x884C
#endif //GL_TEXTURE_COMPARE_MODE_EXT
#ifndef GL_TEXTURE_COMPARE_FUNC_EXT
#define GL_TEXTURE_COMPARE_FUNC_EXT                                     0x884D
#endif //GL_TEXTURE_COMPARE_FUNC_EXT
#ifndef GL_COMPARE_REF_TO_TEXTURE_EXT
#define GL_COMPARE_REF_TO_TEXTURE_EXT                                   0x884E
#endif //GL_COMPARE_REF_TO_TEXTURE_EXT
#ifndef GL_SAMPLER_2D_SHADOW_EXT
#define GL_SAMPLER_2D_SHADOW_EXT                                        0x8B62
#endif //GL_SAMPLER_2D_SHADOW_EXT

#endif //GL_EXT_shadow_samplers

#ifndef GL_EXT_shared_texture_palette

#define GL_EXT_shared_texture_palette
#ifndef GL_SHARED_TEXTURE_PALETTE_EXT
#define GL_SHARED_TEXTURE_PALETTE_EXT                                   0x81FB
#endif //GL_SHARED_TEXTURE_PALETTE_EXT

#endif //GL_EXT_shared_texture_palette

#ifndef GL_EXT_stencil_clear_tag

#define GL_EXT_stencil_clear_tag
#ifndef GL_STENCIL_TAG_BITS_EXT
#define GL_STENCIL_TAG_BITS_EXT                                         0x88F2
#endif //GL_STENCIL_TAG_BITS_EXT
#ifndef GL_STENCIL_CLEAR_TAG_VALUE_EXT
#define GL_STENCIL_CLEAR_TAG_VALUE_EXT                                  0x88F3
#endif //GL_STENCIL_CLEAR_TAG_VALUE_EXT

#endif //GL_EXT_stencil_clear_tag


typedef void (*PFNSTENCILCLEARTAGEXTPROC_HPP)(GLsizei stencilTagBits,GLuint stencilClearTag);

static inline void StencilClearTagEXT(GLsizei stencilTagBits,GLuint stencilClearTag)
{
	static PFNSTENCILCLEARTAGEXTPROC_HPP fn=reinterpret_cast<PFNSTENCILCLEARTAGEXTPROC_HPP>(_impl::_get_proc_address("glStencilClearTagEXT","GL_EXT_stencil_clear_tag"));
	 fn(stencilTagBits,stencilClearTag);
}
#ifndef GL_EXT_stencil_two_side

#define GL_EXT_stencil_two_side
#ifndef GL_STENCIL_TEST_TWO_SIDE_EXT
#define GL_STENCIL_TEST_TWO_SIDE_EXT                                    0x8910
#endif //GL_STENCIL_TEST_TWO_SIDE_EXT
#ifndef GL_ACTIVE_STENCIL_FACE_EXT
#define GL_ACTIVE_STENCIL_FACE_EXT                                      0x8911
#endif //GL_ACTIVE_STENCIL_FACE_EXT

#endif //GL_EXT_stencil_two_side


typedef void (*PFNACTIVESTENCILFACEEXTPROC_HPP)(GLenum face);

static inline void ActiveStencilFaceEXT(GLenum face)
{
	static PFNACTIVESTENCILFACEEXTPROC_HPP fn=reinterpret_cast<PFNACTIVESTENCILFACEEXTPROC_HPP>(_impl::_get_proc_address("glActiveStencilFaceEXT","GL_EXT_stencil_two_side"));
	 fn(face);
}
#ifndef GL_EXT_stencil_wrap

#define GL_EXT_stencil_wrap
#ifndef GL_INCR_WRAP_EXT
#define GL_INCR_WRAP_EXT                                                0x8507
#endif //GL_INCR_WRAP_EXT
#ifndef GL_DECR_WRAP_EXT
#define GL_DECR_WRAP_EXT                                                0x8508
#endif //GL_DECR_WRAP_EXT

#endif //GL_EXT_stencil_wrap

#ifndef GL_EXT_subtexture

#define GL_EXT_subtexture

#endif //GL_EXT_subtexture


typedef void (*PFNTEXSUBIMAGE1DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexSubImage1DEXT(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXSUBIMAGE1DEXTPROC_HPP fn=reinterpret_cast<PFNTEXSUBIMAGE1DEXTPROC_HPP>(_impl::_get_proc_address("glTexSubImage1DEXT","GL_EXT_subtexture"));
	 fn(target,level,xoffset,width,format,type,pixels);
}

typedef void (*PFNTEXSUBIMAGE2DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexSubImage2DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXSUBIMAGE2DEXTPROC_HPP fn=reinterpret_cast<PFNTEXSUBIMAGE2DEXTPROC_HPP>(_impl::_get_proc_address("glTexSubImage2DEXT","GL_EXT_subtexture"));
	 fn(target,level,xoffset,yoffset,width,height,format,type,pixels);
}
#ifndef GL_EXT_texture

#define GL_EXT_texture
#ifndef GL_ALPHA4_EXT
#define GL_ALPHA4_EXT                                                   0x803B
#endif //GL_ALPHA4_EXT
#ifndef GL_ALPHA8_EXT
#define GL_ALPHA8_EXT                                                   0x803C
#endif //GL_ALPHA8_EXT
#ifndef GL_ALPHA12_EXT
#define GL_ALPHA12_EXT                                                  0x803D
#endif //GL_ALPHA12_EXT
#ifndef GL_ALPHA16_EXT
#define GL_ALPHA16_EXT                                                  0x803E
#endif //GL_ALPHA16_EXT
#ifndef GL_LUMINANCE4_EXT
#define GL_LUMINANCE4_EXT                                               0x803F
#endif //GL_LUMINANCE4_EXT
#ifndef GL_LUMINANCE8_EXT
#define GL_LUMINANCE8_EXT                                               0x8040
#endif //GL_LUMINANCE8_EXT
#ifndef GL_LUMINANCE12_EXT
#define GL_LUMINANCE12_EXT                                              0x8041
#endif //GL_LUMINANCE12_EXT
#ifndef GL_LUMINANCE16_EXT
#define GL_LUMINANCE16_EXT                                              0x8042
#endif //GL_LUMINANCE16_EXT
#ifndef GL_LUMINANCE4_ALPHA4_EXT
#define GL_LUMINANCE4_ALPHA4_EXT                                        0x8043
#endif //GL_LUMINANCE4_ALPHA4_EXT
#ifndef GL_LUMINANCE6_ALPHA2_EXT
#define GL_LUMINANCE6_ALPHA2_EXT                                        0x8044
#endif //GL_LUMINANCE6_ALPHA2_EXT
#ifndef GL_LUMINANCE8_ALPHA8_EXT
#define GL_LUMINANCE8_ALPHA8_EXT                                        0x8045
#endif //GL_LUMINANCE8_ALPHA8_EXT
#ifndef GL_LUMINANCE12_ALPHA4_EXT
#define GL_LUMINANCE12_ALPHA4_EXT                                       0x8046
#endif //GL_LUMINANCE12_ALPHA4_EXT
#ifndef GL_LUMINANCE12_ALPHA12_EXT
#define GL_LUMINANCE12_ALPHA12_EXT                                      0x8047
#endif //GL_LUMINANCE12_ALPHA12_EXT
#ifndef GL_LUMINANCE16_ALPHA16_EXT
#define GL_LUMINANCE16_ALPHA16_EXT                                      0x8048
#endif //GL_LUMINANCE16_ALPHA16_EXT
#ifndef GL_INTENSITY_EXT
#define GL_INTENSITY_EXT                                                0x8049
#endif //GL_INTENSITY_EXT
#ifndef GL_INTENSITY4_EXT
#define GL_INTENSITY4_EXT                                               0x804A
#endif //GL_INTENSITY4_EXT
#ifndef GL_INTENSITY8_EXT
#define GL_INTENSITY8_EXT                                               0x804B
#endif //GL_INTENSITY8_EXT
#ifndef GL_INTENSITY12_EXT
#define GL_INTENSITY12_EXT                                              0x804C
#endif //GL_INTENSITY12_EXT
#ifndef GL_INTENSITY16_EXT
#define GL_INTENSITY16_EXT                                              0x804D
#endif //GL_INTENSITY16_EXT
#ifndef GL_RGB2_EXT
#define GL_RGB2_EXT                                                     0x804E
#endif //GL_RGB2_EXT
#ifndef GL_RGB4_EXT
#define GL_RGB4_EXT                                                     0x804F
#endif //GL_RGB4_EXT
#ifndef GL_RGB5_EXT
#define GL_RGB5_EXT                                                     0x8050
#endif //GL_RGB5_EXT
#ifndef GL_RGB8_EXT
#define GL_RGB8_EXT                                                     0x8051
#endif //GL_RGB8_EXT
#ifndef GL_RGB10_EXT
#define GL_RGB10_EXT                                                    0x8052
#endif //GL_RGB10_EXT
#ifndef GL_RGB12_EXT
#define GL_RGB12_EXT                                                    0x8053
#endif //GL_RGB12_EXT
#ifndef GL_RGB16_EXT
#define GL_RGB16_EXT                                                    0x8054
#endif //GL_RGB16_EXT
#ifndef GL_RGBA2_EXT
#define GL_RGBA2_EXT                                                    0x8055
#endif //GL_RGBA2_EXT
#ifndef GL_RGBA4_EXT
#define GL_RGBA4_EXT                                                    0x8056
#endif //GL_RGBA4_EXT
#ifndef GL_RGB5_A1_EXT
#define GL_RGB5_A1_EXT                                                  0x8057
#endif //GL_RGB5_A1_EXT
#ifndef GL_RGBA8_EXT
#define GL_RGBA8_EXT                                                    0x8058
#endif //GL_RGBA8_EXT
#ifndef GL_RGB10_A2_EXT
#define GL_RGB10_A2_EXT                                                 0x8059
#endif //GL_RGB10_A2_EXT
#ifndef GL_RGBA12_EXT
#define GL_RGBA12_EXT                                                   0x805A
#endif //GL_RGBA12_EXT
#ifndef GL_RGBA16_EXT
#define GL_RGBA16_EXT                                                   0x805B
#endif //GL_RGBA16_EXT
#ifndef GL_TEXTURE_RED_SIZE_EXT
#define GL_TEXTURE_RED_SIZE_EXT                                         0x805C
#endif //GL_TEXTURE_RED_SIZE_EXT
#ifndef GL_TEXTURE_GREEN_SIZE_EXT
#define GL_TEXTURE_GREEN_SIZE_EXT                                       0x805D
#endif //GL_TEXTURE_GREEN_SIZE_EXT
#ifndef GL_TEXTURE_BLUE_SIZE_EXT
#define GL_TEXTURE_BLUE_SIZE_EXT                                        0x805E
#endif //GL_TEXTURE_BLUE_SIZE_EXT
#ifndef GL_TEXTURE_ALPHA_SIZE_EXT
#define GL_TEXTURE_ALPHA_SIZE_EXT                                       0x805F
#endif //GL_TEXTURE_ALPHA_SIZE_EXT
#ifndef GL_TEXTURE_LUMINANCE_SIZE_EXT
#define GL_TEXTURE_LUMINANCE_SIZE_EXT                                   0x8060
#endif //GL_TEXTURE_LUMINANCE_SIZE_EXT
#ifndef GL_TEXTURE_INTENSITY_SIZE_EXT
#define GL_TEXTURE_INTENSITY_SIZE_EXT                                   0x8061
#endif //GL_TEXTURE_INTENSITY_SIZE_EXT
#ifndef GL_REPLACE_EXT
#define GL_REPLACE_EXT                                                  0x8062
#endif //GL_REPLACE_EXT
#ifndef GL_PROXY_TEXTURE_1D_EXT
#define GL_PROXY_TEXTURE_1D_EXT                                         0x8063
#endif //GL_PROXY_TEXTURE_1D_EXT
#ifndef GL_PROXY_TEXTURE_2D_EXT
#define GL_PROXY_TEXTURE_2D_EXT                                         0x8064
#endif //GL_PROXY_TEXTURE_2D_EXT
#ifndef GL_TEXTURE_TOO_LARGE_EXT
#define GL_TEXTURE_TOO_LARGE_EXT                                        0x8065
#endif //GL_TEXTURE_TOO_LARGE_EXT

#endif //GL_EXT_texture

#ifndef GL_EXT_texture3D

#define GL_EXT_texture3D
#ifndef GL_PACK_SKIP_IMAGES_EXT
#define GL_PACK_SKIP_IMAGES_EXT                                         0x806B
#endif //GL_PACK_SKIP_IMAGES_EXT
#ifndef GL_PACK_IMAGE_HEIGHT_EXT
#define GL_PACK_IMAGE_HEIGHT_EXT                                        0x806C
#endif //GL_PACK_IMAGE_HEIGHT_EXT
#ifndef GL_UNPACK_SKIP_IMAGES_EXT
#define GL_UNPACK_SKIP_IMAGES_EXT                                       0x806D
#endif //GL_UNPACK_SKIP_IMAGES_EXT
#ifndef GL_UNPACK_IMAGE_HEIGHT_EXT
#define GL_UNPACK_IMAGE_HEIGHT_EXT                                      0x806E
#endif //GL_UNPACK_IMAGE_HEIGHT_EXT
#ifndef GL_TEXTURE_3D_EXT
#define GL_TEXTURE_3D_EXT                                               0x806F
#endif //GL_TEXTURE_3D_EXT
#ifndef GL_PROXY_TEXTURE_3D_EXT
#define GL_PROXY_TEXTURE_3D_EXT                                         0x8070
#endif //GL_PROXY_TEXTURE_3D_EXT
#ifndef GL_TEXTURE_DEPTH_EXT
#define GL_TEXTURE_DEPTH_EXT                                            0x8071
#endif //GL_TEXTURE_DEPTH_EXT
#ifndef GL_TEXTURE_WRAP_R_EXT
#define GL_TEXTURE_WRAP_R_EXT                                           0x8072
#endif //GL_TEXTURE_WRAP_R_EXT
#ifndef GL_MAX_3D_TEXTURE_SIZE_EXT
#define GL_MAX_3D_TEXTURE_SIZE_EXT                                      0x8073
#endif //GL_MAX_3D_TEXTURE_SIZE_EXT

#endif //GL_EXT_texture3D


typedef void (*PFNTEXIMAGE3DEXTPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexImage3DEXT(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glTexImage3DEXT","GL_EXT_texture3D"));
	 fn(target,level,internalformat,width,height,depth,border,format,type,pixels);
}

typedef void (*PFNTEXSUBIMAGE3DEXTPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexSubImage3DEXT(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXSUBIMAGE3DEXTPROC_HPP fn=reinterpret_cast<PFNTEXSUBIMAGE3DEXTPROC_HPP>(_impl::_get_proc_address("glTexSubImage3DEXT","GL_EXT_texture3D"));
	 fn(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels);
}
#ifndef GL_EXT_texture_array

#define GL_EXT_texture_array
#ifndef GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT
#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT                             0x884E
#endif //GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT
#ifndef GL_MAX_ARRAY_TEXTURE_LAYERS_EXT
#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT                                 0x88FF
#endif //GL_MAX_ARRAY_TEXTURE_LAYERS_EXT
#ifndef GL_TEXTURE_1D_ARRAY_EXT
#define GL_TEXTURE_1D_ARRAY_EXT                                         0x8C18
#endif //GL_TEXTURE_1D_ARRAY_EXT
#ifndef GL_PROXY_TEXTURE_1D_ARRAY_EXT
#define GL_PROXY_TEXTURE_1D_ARRAY_EXT                                   0x8C19
#endif //GL_PROXY_TEXTURE_1D_ARRAY_EXT
#ifndef GL_TEXTURE_2D_ARRAY_EXT
#define GL_TEXTURE_2D_ARRAY_EXT                                         0x8C1A
#endif //GL_TEXTURE_2D_ARRAY_EXT
#ifndef GL_PROXY_TEXTURE_2D_ARRAY_EXT
#define GL_PROXY_TEXTURE_2D_ARRAY_EXT                                   0x8C1B
#endif //GL_PROXY_TEXTURE_2D_ARRAY_EXT
#ifndef GL_TEXTURE_BINDING_1D_ARRAY_EXT
#define GL_TEXTURE_BINDING_1D_ARRAY_EXT                                 0x8C1C
#endif //GL_TEXTURE_BINDING_1D_ARRAY_EXT
#ifndef GL_TEXTURE_BINDING_2D_ARRAY_EXT
#define GL_TEXTURE_BINDING_2D_ARRAY_EXT                                 0x8C1D
#endif //GL_TEXTURE_BINDING_2D_ARRAY_EXT

#endif //GL_EXT_texture_array

#ifndef GL_EXT_texture_buffer_object

#define GL_EXT_texture_buffer_object
#ifndef GL_TEXTURE_BUFFER_EXT
#define GL_TEXTURE_BUFFER_EXT                                           0x8C2A
#endif //GL_TEXTURE_BUFFER_EXT
#ifndef GL_MAX_TEXTURE_BUFFER_SIZE_EXT
#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT                                  0x8C2B
#endif //GL_MAX_TEXTURE_BUFFER_SIZE_EXT
#ifndef GL_TEXTURE_BINDING_BUFFER_EXT
#define GL_TEXTURE_BINDING_BUFFER_EXT                                   0x8C2C
#endif //GL_TEXTURE_BINDING_BUFFER_EXT
#ifndef GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT
#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT                        0x8C2D
#endif //GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT
#ifndef GL_TEXTURE_BUFFER_FORMAT_EXT
#define GL_TEXTURE_BUFFER_FORMAT_EXT                                    0x8C2E
#endif //GL_TEXTURE_BUFFER_FORMAT_EXT

#endif //GL_EXT_texture_buffer_object


typedef void (*PFNTEXBUFFEREXTPROC_HPP)(GLenum target,GLenum internalformat,GLuint buffer);

static inline void TexBufferEXT(GLenum target,GLenum internalformat,GLuint buffer)
{
	static PFNTEXBUFFEREXTPROC_HPP fn=reinterpret_cast<PFNTEXBUFFEREXTPROC_HPP>(_impl::_get_proc_address("glTexBufferEXT","GL_EXT_texture_buffer_object"));
	 fn(target,internalformat,buffer);
}
#ifndef GL_EXT_texture_compression_latc

#define GL_EXT_texture_compression_latc
#ifndef GL_COMPRESSED_LUMINANCE_LATC1_EXT
#define GL_COMPRESSED_LUMINANCE_LATC1_EXT                               0x8C70
#endif //GL_COMPRESSED_LUMINANCE_LATC1_EXT
#ifndef GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT
#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT                        0x8C71
#endif //GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT
#ifndef GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT
#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT                         0x8C72
#endif //GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT
#ifndef GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT
#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT                  0x8C73
#endif //GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT

#endif //GL_EXT_texture_compression_latc

#ifndef GL_EXT_texture_compression_rgtc

#define GL_EXT_texture_compression_rgtc
#ifndef GL_COMPRESSED_RED_RGTC1_EXT
#define GL_COMPRESSED_RED_RGTC1_EXT                                     0x8DBB
#endif //GL_COMPRESSED_RED_RGTC1_EXT
#ifndef GL_COMPRESSED_SIGNED_RED_RGTC1_EXT
#define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT                              0x8DBC
#endif //GL_COMPRESSED_SIGNED_RED_RGTC1_EXT
#ifndef GL_COMPRESSED_RED_GREEN_RGTC2_EXT
#define GL_COMPRESSED_RED_GREEN_RGTC2_EXT                               0x8DBD
#endif //GL_COMPRESSED_RED_GREEN_RGTC2_EXT
#ifndef GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT
#define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT                        0x8DBE
#endif //GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT

#endif //GL_EXT_texture_compression_rgtc

#ifndef GL_EXT_texture_compression_s3tc

#define GL_EXT_texture_compression_s3tc
#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                                 0x83F0
#endif //GL_COMPRESSED_RGB_S3TC_DXT1_EXT
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                                0x83F1
#endif //GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                                0x83F2
#endif //GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                                0x83F3
#endif //GL_COMPRESSED_RGBA_S3TC_DXT5_EXT

#endif //GL_EXT_texture_compression_s3tc

#ifndef GL_EXT_texture_cube_map

#define GL_EXT_texture_cube_map
#ifndef GL_NORMAL_MAP_EXT
#define GL_NORMAL_MAP_EXT                                               0x8511
#endif //GL_NORMAL_MAP_EXT
#ifndef GL_REFLECTION_MAP_EXT
#define GL_REFLECTION_MAP_EXT                                           0x8512
#endif //GL_REFLECTION_MAP_EXT
#ifndef GL_TEXTURE_CUBE_MAP_EXT
#define GL_TEXTURE_CUBE_MAP_EXT                                         0x8513
#endif //GL_TEXTURE_CUBE_MAP_EXT
#ifndef GL_TEXTURE_BINDING_CUBE_MAP_EXT
#define GL_TEXTURE_BINDING_CUBE_MAP_EXT                                 0x8514
#endif //GL_TEXTURE_BINDING_CUBE_MAP_EXT
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT                              0x8515
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT                              0x8516
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT                              0x8517
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT                              0x8518
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT                              0x8519
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT                              0x851A
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT
#ifndef GL_PROXY_TEXTURE_CUBE_MAP_EXT
#define GL_PROXY_TEXTURE_CUBE_MAP_EXT                                   0x851B
#endif //GL_PROXY_TEXTURE_CUBE_MAP_EXT
#ifndef GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT
#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT                                0x851C
#endif //GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT

#endif //GL_EXT_texture_cube_map

#ifndef GL_EXT_texture_env_combine

#define GL_EXT_texture_env_combine
#ifndef GL_COMBINE_EXT
#define GL_COMBINE_EXT                                                  0x8570
#endif //GL_COMBINE_EXT
#ifndef GL_COMBINE_RGB_EXT
#define GL_COMBINE_RGB_EXT                                              0x8571
#endif //GL_COMBINE_RGB_EXT
#ifndef GL_COMBINE_ALPHA_EXT
#define GL_COMBINE_ALPHA_EXT                                            0x8572
#endif //GL_COMBINE_ALPHA_EXT
#ifndef GL_RGB_SCALE_EXT
#define GL_RGB_SCALE_EXT                                                0x8573
#endif //GL_RGB_SCALE_EXT
#ifndef GL_ADD_SIGNED_EXT
#define GL_ADD_SIGNED_EXT                                               0x8574
#endif //GL_ADD_SIGNED_EXT
#ifndef GL_INTERPOLATE_EXT
#define GL_INTERPOLATE_EXT                                              0x8575
#endif //GL_INTERPOLATE_EXT
#ifndef GL_CONSTANT_EXT
#define GL_CONSTANT_EXT                                                 0x8576
#endif //GL_CONSTANT_EXT
#ifndef GL_PRIMARY_COLOR_EXT
#define GL_PRIMARY_COLOR_EXT                                            0x8577
#endif //GL_PRIMARY_COLOR_EXT
#ifndef GL_PREVIOUS_EXT
#define GL_PREVIOUS_EXT                                                 0x8578
#endif //GL_PREVIOUS_EXT
#ifndef GL_SOURCE0_RGB_EXT
#define GL_SOURCE0_RGB_EXT                                              0x8580
#endif //GL_SOURCE0_RGB_EXT
#ifndef GL_SOURCE1_RGB_EXT
#define GL_SOURCE1_RGB_EXT                                              0x8581
#endif //GL_SOURCE1_RGB_EXT
#ifndef GL_SOURCE2_RGB_EXT
#define GL_SOURCE2_RGB_EXT                                              0x8582
#endif //GL_SOURCE2_RGB_EXT
#ifndef GL_SOURCE0_ALPHA_EXT
#define GL_SOURCE0_ALPHA_EXT                                            0x8588
#endif //GL_SOURCE0_ALPHA_EXT
#ifndef GL_SOURCE1_ALPHA_EXT
#define GL_SOURCE1_ALPHA_EXT                                            0x8589
#endif //GL_SOURCE1_ALPHA_EXT
#ifndef GL_SOURCE2_ALPHA_EXT
#define GL_SOURCE2_ALPHA_EXT                                            0x858A
#endif //GL_SOURCE2_ALPHA_EXT
#ifndef GL_OPERAND0_RGB_EXT
#define GL_OPERAND0_RGB_EXT                                             0x8590
#endif //GL_OPERAND0_RGB_EXT
#ifndef GL_OPERAND1_RGB_EXT
#define GL_OPERAND1_RGB_EXT                                             0x8591
#endif //GL_OPERAND1_RGB_EXT
#ifndef GL_OPERAND2_RGB_EXT
#define GL_OPERAND2_RGB_EXT                                             0x8592
#endif //GL_OPERAND2_RGB_EXT
#ifndef GL_OPERAND0_ALPHA_EXT
#define GL_OPERAND0_ALPHA_EXT                                           0x8598
#endif //GL_OPERAND0_ALPHA_EXT
#ifndef GL_OPERAND1_ALPHA_EXT
#define GL_OPERAND1_ALPHA_EXT                                           0x8599
#endif //GL_OPERAND1_ALPHA_EXT
#ifndef GL_OPERAND2_ALPHA_EXT
#define GL_OPERAND2_ALPHA_EXT                                           0x859A
#endif //GL_OPERAND2_ALPHA_EXT

#endif //GL_EXT_texture_env_combine

#ifndef GL_EXT_texture_env_dot3

#define GL_EXT_texture_env_dot3
#ifndef GL_DOT3_RGB_EXT
#define GL_DOT3_RGB_EXT                                                 0x8740
#endif //GL_DOT3_RGB_EXT
#ifndef GL_DOT3_RGBA_EXT
#define GL_DOT3_RGBA_EXT                                                0x8741
#endif //GL_DOT3_RGBA_EXT

#endif //GL_EXT_texture_env_dot3

#ifndef GL_EXT_texture_filter_anisotropic

#define GL_EXT_texture_filter_anisotropic
#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT
#define GL_TEXTURE_MAX_ANISOTROPY_EXT                                   0x84FE
#endif //GL_TEXTURE_MAX_ANISOTROPY_EXT
#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT                               0x84FF
#endif //GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT

#endif //GL_EXT_texture_filter_anisotropic

#ifndef GL_EXT_texture_integer

#define GL_EXT_texture_integer
#ifndef GL_RGBA32UI
#define GL_RGBA32UI                                                     0x8D70
#endif //GL_RGBA32UI
#ifndef GL_RGBA32UI_EXT
#define GL_RGBA32UI_EXT                                                 0x8D70
#endif //GL_RGBA32UI_EXT
#ifndef GL_RGB32UI
#define GL_RGB32UI                                                      0x8D71
#endif //GL_RGB32UI
#ifndef GL_RGB32UI_EXT
#define GL_RGB32UI_EXT                                                  0x8D71
#endif //GL_RGB32UI_EXT
#ifndef GL_ALPHA32UI_EXT
#define GL_ALPHA32UI_EXT                                                0x8D72
#endif //GL_ALPHA32UI_EXT
#ifndef GL_INTENSITY32UI_EXT
#define GL_INTENSITY32UI_EXT                                            0x8D73
#endif //GL_INTENSITY32UI_EXT
#ifndef GL_LUMINANCE32UI_EXT
#define GL_LUMINANCE32UI_EXT                                            0x8D74
#endif //GL_LUMINANCE32UI_EXT
#ifndef GL_LUMINANCE_ALPHA32UI_EXT
#define GL_LUMINANCE_ALPHA32UI_EXT                                      0x8D75
#endif //GL_LUMINANCE_ALPHA32UI_EXT
#ifndef GL_RGBA16UI
#define GL_RGBA16UI                                                     0x8D76
#endif //GL_RGBA16UI
#ifndef GL_RGBA16UI_EXT
#define GL_RGBA16UI_EXT                                                 0x8D76
#endif //GL_RGBA16UI_EXT
#ifndef GL_RGB16UI
#define GL_RGB16UI                                                      0x8D77
#endif //GL_RGB16UI
#ifndef GL_RGB16UI_EXT
#define GL_RGB16UI_EXT                                                  0x8D77
#endif //GL_RGB16UI_EXT
#ifndef GL_ALPHA16UI_EXT
#define GL_ALPHA16UI_EXT                                                0x8D78
#endif //GL_ALPHA16UI_EXT
#ifndef GL_INTENSITY16UI_EXT
#define GL_INTENSITY16UI_EXT                                            0x8D79
#endif //GL_INTENSITY16UI_EXT
#ifndef GL_LUMINANCE16UI_EXT
#define GL_LUMINANCE16UI_EXT                                            0x8D7A
#endif //GL_LUMINANCE16UI_EXT
#ifndef GL_LUMINANCE_ALPHA16UI_EXT
#define GL_LUMINANCE_ALPHA16UI_EXT                                      0x8D7B
#endif //GL_LUMINANCE_ALPHA16UI_EXT
#ifndef GL_RGBA8UI
#define GL_RGBA8UI                                                      0x8D7C
#endif //GL_RGBA8UI
#ifndef GL_RGBA8UI_EXT
#define GL_RGBA8UI_EXT                                                  0x8D7C
#endif //GL_RGBA8UI_EXT
#ifndef GL_RGB8UI
#define GL_RGB8UI                                                       0x8D7D
#endif //GL_RGB8UI
#ifndef GL_RGB8UI_EXT
#define GL_RGB8UI_EXT                                                   0x8D7D
#endif //GL_RGB8UI_EXT
#ifndef GL_ALPHA8UI_EXT
#define GL_ALPHA8UI_EXT                                                 0x8D7E
#endif //GL_ALPHA8UI_EXT
#ifndef GL_INTENSITY8UI_EXT
#define GL_INTENSITY8UI_EXT                                             0x8D7F
#endif //GL_INTENSITY8UI_EXT
#ifndef GL_LUMINANCE8UI_EXT
#define GL_LUMINANCE8UI_EXT                                             0x8D80
#endif //GL_LUMINANCE8UI_EXT
#ifndef GL_LUMINANCE_ALPHA8UI_EXT
#define GL_LUMINANCE_ALPHA8UI_EXT                                       0x8D81
#endif //GL_LUMINANCE_ALPHA8UI_EXT
#ifndef GL_RGBA32I_EXT
#define GL_RGBA32I_EXT                                                  0x8D82
#endif //GL_RGBA32I_EXT
#ifndef GL_RGBA32I
#define GL_RGBA32I                                                      0x8D82
#endif //GL_RGBA32I
#ifndef GL_RGB32I
#define GL_RGB32I                                                       0x8D83
#endif //GL_RGB32I
#ifndef GL_RGB32I_EXT
#define GL_RGB32I_EXT                                                   0x8D83
#endif //GL_RGB32I_EXT
#ifndef GL_ALPHA32I_EXT
#define GL_ALPHA32I_EXT                                                 0x8D84
#endif //GL_ALPHA32I_EXT
#ifndef GL_INTENSITY32I_EXT
#define GL_INTENSITY32I_EXT                                             0x8D85
#endif //GL_INTENSITY32I_EXT
#ifndef GL_LUMINANCE32I_EXT
#define GL_LUMINANCE32I_EXT                                             0x8D86
#endif //GL_LUMINANCE32I_EXT
#ifndef GL_LUMINANCE_ALPHA32I_EXT
#define GL_LUMINANCE_ALPHA32I_EXT                                       0x8D87
#endif //GL_LUMINANCE_ALPHA32I_EXT
#ifndef GL_RGBA16I_EXT
#define GL_RGBA16I_EXT                                                  0x8D88
#endif //GL_RGBA16I_EXT
#ifndef GL_RGBA16I
#define GL_RGBA16I                                                      0x8D88
#endif //GL_RGBA16I
#ifndef GL_RGB16I
#define GL_RGB16I                                                       0x8D89
#endif //GL_RGB16I
#ifndef GL_RGB16I_EXT
#define GL_RGB16I_EXT                                                   0x8D89
#endif //GL_RGB16I_EXT
#ifndef GL_ALPHA16I_EXT
#define GL_ALPHA16I_EXT                                                 0x8D8A
#endif //GL_ALPHA16I_EXT
#ifndef GL_INTENSITY16I_EXT
#define GL_INTENSITY16I_EXT                                             0x8D8B
#endif //GL_INTENSITY16I_EXT
#ifndef GL_LUMINANCE16I_EXT
#define GL_LUMINANCE16I_EXT                                             0x8D8C
#endif //GL_LUMINANCE16I_EXT
#ifndef GL_LUMINANCE_ALPHA16I_EXT
#define GL_LUMINANCE_ALPHA16I_EXT                                       0x8D8D
#endif //GL_LUMINANCE_ALPHA16I_EXT
#ifndef GL_RGBA8I
#define GL_RGBA8I                                                       0x8D8E
#endif //GL_RGBA8I
#ifndef GL_RGBA8I_EXT
#define GL_RGBA8I_EXT                                                   0x8D8E
#endif //GL_RGBA8I_EXT
#ifndef GL_RGB8I_EXT
#define GL_RGB8I_EXT                                                    0x8D8F
#endif //GL_RGB8I_EXT
#ifndef GL_RGB8I
#define GL_RGB8I                                                        0x8D8F
#endif //GL_RGB8I
#ifndef GL_ALPHA8I_EXT
#define GL_ALPHA8I_EXT                                                  0x8D90
#endif //GL_ALPHA8I_EXT
#ifndef GL_INTENSITY8I_EXT
#define GL_INTENSITY8I_EXT                                              0x8D91
#endif //GL_INTENSITY8I_EXT
#ifndef GL_LUMINANCE8I_EXT
#define GL_LUMINANCE8I_EXT                                              0x8D92
#endif //GL_LUMINANCE8I_EXT
#ifndef GL_LUMINANCE_ALPHA8I_EXT
#define GL_LUMINANCE_ALPHA8I_EXT                                        0x8D93
#endif //GL_LUMINANCE_ALPHA8I_EXT
#ifndef GL_RED_INTEGER_EXT
#define GL_RED_INTEGER_EXT                                              0x8D94
#endif //GL_RED_INTEGER_EXT
#ifndef GL_RED_INTEGER
#define GL_RED_INTEGER                                                  0x8D94
#endif //GL_RED_INTEGER
#ifndef GL_GREEN_INTEGER_EXT
#define GL_GREEN_INTEGER_EXT                                            0x8D95
#endif //GL_GREEN_INTEGER_EXT
#ifndef GL_GREEN_INTEGER
#define GL_GREEN_INTEGER                                                0x8D95
#endif //GL_GREEN_INTEGER
#ifndef GL_BLUE_INTEGER
#define GL_BLUE_INTEGER                                                 0x8D96
#endif //GL_BLUE_INTEGER
#ifndef GL_BLUE_INTEGER_EXT
#define GL_BLUE_INTEGER_EXT                                             0x8D96
#endif //GL_BLUE_INTEGER_EXT
#ifndef GL_ALPHA_INTEGER
#define GL_ALPHA_INTEGER                                                0x8D97
#endif //GL_ALPHA_INTEGER
#ifndef GL_ALPHA_INTEGER_EXT
#define GL_ALPHA_INTEGER_EXT                                            0x8D97
#endif //GL_ALPHA_INTEGER_EXT
#ifndef GL_RGB_INTEGER
#define GL_RGB_INTEGER                                                  0x8D98
#endif //GL_RGB_INTEGER
#ifndef GL_RGB_INTEGER_EXT
#define GL_RGB_INTEGER_EXT                                              0x8D98
#endif //GL_RGB_INTEGER_EXT
#ifndef GL_RGBA_INTEGER
#define GL_RGBA_INTEGER                                                 0x8D99
#endif //GL_RGBA_INTEGER
#ifndef GL_RGBA_INTEGER_EXT
#define GL_RGBA_INTEGER_EXT                                             0x8D99
#endif //GL_RGBA_INTEGER_EXT
#ifndef GL_BGR_INTEGER_EXT
#define GL_BGR_INTEGER_EXT                                              0x8D9A
#endif //GL_BGR_INTEGER_EXT
#ifndef GL_BGR_INTEGER
#define GL_BGR_INTEGER                                                  0x8D9A
#endif //GL_BGR_INTEGER
#ifndef GL_BGRA_INTEGER
#define GL_BGRA_INTEGER                                                 0x8D9B
#endif //GL_BGRA_INTEGER
#ifndef GL_BGRA_INTEGER_EXT
#define GL_BGRA_INTEGER_EXT                                             0x8D9B
#endif //GL_BGRA_INTEGER_EXT
#ifndef GL_LUMINANCE_INTEGER_EXT
#define GL_LUMINANCE_INTEGER_EXT                                        0x8D9C
#endif //GL_LUMINANCE_INTEGER_EXT
#ifndef GL_LUMINANCE_ALPHA_INTEGER_EXT
#define GL_LUMINANCE_ALPHA_INTEGER_EXT                                  0x8D9D
#endif //GL_LUMINANCE_ALPHA_INTEGER_EXT
#ifndef GL_RGBA_INTEGER_MODE_EXT
#define GL_RGBA_INTEGER_MODE_EXT                                        0x8D9E
#endif //GL_RGBA_INTEGER_MODE_EXT

#endif //GL_EXT_texture_integer


typedef void (*PFNTEXPARAMETERIIVEXTPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void TexParameterIivEXT(GLenum target,GLenum pname,const GLint *params)
{
	static PFNTEXPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNTEXPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glTexParameterIivEXT","GL_EXT_texture_integer"));
	 fn(target,pname,params);
}

typedef void (*PFNTEXPARAMETERIUIVEXTPROC_HPP)(GLenum target,GLenum pname,const GLuint *params);

static inline void TexParameterIuivEXT(GLenum target,GLenum pname,const GLuint *params)
{
	static PFNTEXPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNTEXPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glTexParameterIuivEXT","GL_EXT_texture_integer"));
	 fn(target,pname,params);
}

typedef void (*PFNGETTEXPARAMETERIIVEXTPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetTexParameterIivEXT(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETTEXPARAMETERIIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXPARAMETERIIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTexParameterIivEXT","GL_EXT_texture_integer"));
	 fn(target,pname,params);
}

typedef void (*PFNGETTEXPARAMETERIUIVEXTPROC_HPP)(GLenum target,GLenum pname,GLuint *params);

static inline void GetTexParameterIuivEXT(GLenum target,GLenum pname,GLuint *params)
{
	static PFNGETTEXPARAMETERIUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETTEXPARAMETERIUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetTexParameterIuivEXT","GL_EXT_texture_integer"));
	 fn(target,pname,params);
}

typedef void (*PFNCLEARCOLORIIEXTPROC_HPP)(GLint red,GLint green,GLint blue,GLint alpha);

static inline void ClearColorIiEXT(GLint red,GLint green,GLint blue,GLint alpha)
{
	static PFNCLEARCOLORIIEXTPROC_HPP fn=reinterpret_cast<PFNCLEARCOLORIIEXTPROC_HPP>(_impl::_get_proc_address("glClearColorIiEXT","GL_EXT_texture_integer"));
	 fn(red,green,blue,alpha);
}

typedef void (*PFNCLEARCOLORIUIEXTPROC_HPP)(GLuint red,GLuint green,GLuint blue,GLuint alpha);

static inline void ClearColorIuiEXT(GLuint red,GLuint green,GLuint blue,GLuint alpha)
{
	static PFNCLEARCOLORIUIEXTPROC_HPP fn=reinterpret_cast<PFNCLEARCOLORIUIEXTPROC_HPP>(_impl::_get_proc_address("glClearColorIuiEXT","GL_EXT_texture_integer"));
	 fn(red,green,blue,alpha);
}
#ifndef GL_EXT_texture_lod_bias

#define GL_EXT_texture_lod_bias
#ifndef GL_MAX_TEXTURE_LOD_BIAS_EXT
#define GL_MAX_TEXTURE_LOD_BIAS_EXT                                     0x84FD
#endif //GL_MAX_TEXTURE_LOD_BIAS_EXT
#ifndef GL_TEXTURE_FILTER_CONTROL_EXT
#define GL_TEXTURE_FILTER_CONTROL_EXT                                   0x8500
#endif //GL_TEXTURE_FILTER_CONTROL_EXT
#ifndef GL_TEXTURE_LOD_BIAS_EXT
#define GL_TEXTURE_LOD_BIAS_EXT                                         0x8501
#endif //GL_TEXTURE_LOD_BIAS_EXT

#endif //GL_EXT_texture_lod_bias

#ifndef GL_EXT_texture_mirror_clamp

#define GL_EXT_texture_mirror_clamp
#ifndef GL_MIRROR_CLAMP_EXT
#define GL_MIRROR_CLAMP_EXT                                             0x8742
#endif //GL_MIRROR_CLAMP_EXT
#ifndef GL_MIRROR_CLAMP_TO_EDGE_EXT
#define GL_MIRROR_CLAMP_TO_EDGE_EXT                                     0x8743
#endif //GL_MIRROR_CLAMP_TO_EDGE_EXT
#ifndef GL_MIRROR_CLAMP_TO_BORDER_EXT
#define GL_MIRROR_CLAMP_TO_BORDER_EXT                                   0x8912
#endif //GL_MIRROR_CLAMP_TO_BORDER_EXT

#endif //GL_EXT_texture_mirror_clamp

#ifndef GL_EXT_texture_object

#define GL_EXT_texture_object
#ifndef GL_TEXTURE_PRIORITY_EXT
#define GL_TEXTURE_PRIORITY_EXT                                         0x8066
#endif //GL_TEXTURE_PRIORITY_EXT
#ifndef GL_TEXTURE_RESIDENT_EXT
#define GL_TEXTURE_RESIDENT_EXT                                         0x8067
#endif //GL_TEXTURE_RESIDENT_EXT
#ifndef GL_TEXTURE_1D_BINDING_EXT
#define GL_TEXTURE_1D_BINDING_EXT                                       0x8068
#endif //GL_TEXTURE_1D_BINDING_EXT
#ifndef GL_TEXTURE_2D_BINDING_EXT
#define GL_TEXTURE_2D_BINDING_EXT                                       0x8069
#endif //GL_TEXTURE_2D_BINDING_EXT
#ifndef GL_TEXTURE_3D_BINDING_EXT
#define GL_TEXTURE_3D_BINDING_EXT                                       0x806A
#endif //GL_TEXTURE_3D_BINDING_EXT

#endif //GL_EXT_texture_object


typedef GLboolean (*PFNARETEXTURESRESIDENTEXTPROC_HPP)(GLsizei n,const GLuint *textures,GLboolean *residences);

static inline GLboolean AreTexturesResidentEXT(GLsizei n,const GLuint *textures,GLboolean *residences)
{
	static PFNARETEXTURESRESIDENTEXTPROC_HPP fn=reinterpret_cast<PFNARETEXTURESRESIDENTEXTPROC_HPP>(_impl::_get_proc_address("glAreTexturesResidentEXT","GL_EXT_texture_object"));
	return fn(n,textures,residences);
}

typedef void (*PFNBINDTEXTUREEXTPROC_HPP)(GLenum target,GLuint texture);

static inline void BindTextureEXT(GLenum target,GLuint texture)
{
	static PFNBINDTEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNBINDTEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glBindTextureEXT","GL_EXT_texture_object"));
	 fn(target,texture);
}

typedef void (*PFNDELETETEXTURESEXTPROC_HPP)(GLsizei n,const GLuint *textures);

static inline void DeleteTexturesEXT(GLsizei n,const GLuint *textures)
{
	static PFNDELETETEXTURESEXTPROC_HPP fn=reinterpret_cast<PFNDELETETEXTURESEXTPROC_HPP>(_impl::_get_proc_address("glDeleteTexturesEXT","GL_EXT_texture_object"));
	 fn(n,textures);
}

typedef void (*PFNGENTEXTURESEXTPROC_HPP)(GLsizei n,GLuint *textures);

static inline void GenTexturesEXT(GLsizei n,GLuint *textures)
{
	static PFNGENTEXTURESEXTPROC_HPP fn=reinterpret_cast<PFNGENTEXTURESEXTPROC_HPP>(_impl::_get_proc_address("glGenTexturesEXT","GL_EXT_texture_object"));
	 fn(n,textures);
}

typedef GLboolean (*PFNISTEXTUREEXTPROC_HPP)(GLuint texture);

static inline GLboolean IsTextureEXT(GLuint texture)
{
	static PFNISTEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNISTEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glIsTextureEXT","GL_EXT_texture_object"));
	return fn(texture);
}

typedef void (*PFNPRIORITIZETEXTURESEXTPROC_HPP)(GLsizei n,const GLuint *textures,const GLclampf *priorities);

static inline void PrioritizeTexturesEXT(GLsizei n,const GLuint *textures,const GLclampf *priorities)
{
	static PFNPRIORITIZETEXTURESEXTPROC_HPP fn=reinterpret_cast<PFNPRIORITIZETEXTURESEXTPROC_HPP>(_impl::_get_proc_address("glPrioritizeTexturesEXT","GL_EXT_texture_object"));
	 fn(n,textures,priorities);
}
#ifndef GL_EXT_texture_perturb_normal

#define GL_EXT_texture_perturb_normal
#ifndef GL_PERTURB_EXT
#define GL_PERTURB_EXT                                                  0x85AE
#endif //GL_PERTURB_EXT
#ifndef GL_TEXTURE_NORMAL_EXT
#define GL_TEXTURE_NORMAL_EXT                                           0x85AF
#endif //GL_TEXTURE_NORMAL_EXT

#endif //GL_EXT_texture_perturb_normal


typedef void (*PFNTEXTURENORMALEXTPROC_HPP)(GLenum mode);

static inline void TextureNormalEXT(GLenum mode)
{
	static PFNTEXTURENORMALEXTPROC_HPP fn=reinterpret_cast<PFNTEXTURENORMALEXTPROC_HPP>(_impl::_get_proc_address("glTextureNormalEXT","GL_EXT_texture_perturb_normal"));
	 fn(mode);
}
#ifndef GL_EXT_texture_rg

#define GL_EXT_texture_rg
#ifndef GL_RED_EXT
#define GL_RED_EXT                                                      0x1903
#endif //GL_RED_EXT
#ifndef GL_RG_EXT
#define GL_RG_EXT                                                       0x8227
#endif //GL_RG_EXT
#ifndef GL_R8_EXT
#define GL_R8_EXT                                                       0x8229
#endif //GL_R8_EXT
#ifndef GL_RG8_EXT
#define GL_RG8_EXT                                                      0x822B
#endif //GL_RG8_EXT

#endif //GL_EXT_texture_rg

#ifndef GL_EXT_texture_sRGB

#define GL_EXT_texture_sRGB
#ifndef GL_SRGB_EXT
#define GL_SRGB_EXT                                                     0x8C40
#endif //GL_SRGB_EXT
#ifndef GL_SRGB8_EXT
#define GL_SRGB8_EXT                                                    0x8C41
#endif //GL_SRGB8_EXT
#ifndef GL_SRGB_ALPHA_EXT
#define GL_SRGB_ALPHA_EXT                                               0x8C42
#endif //GL_SRGB_ALPHA_EXT
#ifndef GL_SRGB8_ALPHA8_EXT
#define GL_SRGB8_ALPHA8_EXT                                             0x8C43
#endif //GL_SRGB8_ALPHA8_EXT
#ifndef GL_SLUMINANCE_ALPHA_EXT
#define GL_SLUMINANCE_ALPHA_EXT                                         0x8C44
#endif //GL_SLUMINANCE_ALPHA_EXT
#ifndef GL_SLUMINANCE8_ALPHA8_EXT
#define GL_SLUMINANCE8_ALPHA8_EXT                                       0x8C45
#endif //GL_SLUMINANCE8_ALPHA8_EXT
#ifndef GL_SLUMINANCE_EXT
#define GL_SLUMINANCE_EXT                                               0x8C46
#endif //GL_SLUMINANCE_EXT
#ifndef GL_SLUMINANCE8_EXT
#define GL_SLUMINANCE8_EXT                                              0x8C47
#endif //GL_SLUMINANCE8_EXT
#ifndef GL_COMPRESSED_SRGB_EXT
#define GL_COMPRESSED_SRGB_EXT                                          0x8C48
#endif //GL_COMPRESSED_SRGB_EXT
#ifndef GL_COMPRESSED_SRGB_ALPHA_EXT
#define GL_COMPRESSED_SRGB_ALPHA_EXT                                    0x8C49
#endif //GL_COMPRESSED_SRGB_ALPHA_EXT
#ifndef GL_COMPRESSED_SLUMINANCE_EXT
#define GL_COMPRESSED_SLUMINANCE_EXT                                    0x8C4A
#endif //GL_COMPRESSED_SLUMINANCE_EXT
#ifndef GL_COMPRESSED_SLUMINANCE_ALPHA_EXT
#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT                              0x8C4B
#endif //GL_COMPRESSED_SLUMINANCE_ALPHA_EXT
#ifndef GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT                                0x8C4C
#endif //GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
#ifndef GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT                          0x8C4D
#endif //GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
#ifndef GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT                          0x8C4E
#endif //GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
#ifndef GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT                          0x8C4F
#endif //GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT

#endif //GL_EXT_texture_sRGB

#ifndef GL_EXT_texture_sRGB_decode

#define GL_EXT_texture_sRGB_decode
#ifndef GL_TEXTURE_SRGB_DECODE_EXT
#define GL_TEXTURE_SRGB_DECODE_EXT                                      0x8A48
#endif //GL_TEXTURE_SRGB_DECODE_EXT
#ifndef GL_DECODE_EXT
#define GL_DECODE_EXT                                                   0x8A49
#endif //GL_DECODE_EXT
#ifndef GL_SKIP_DECODE_EXT
#define GL_SKIP_DECODE_EXT                                              0x8A4A
#endif //GL_SKIP_DECODE_EXT

#endif //GL_EXT_texture_sRGB_decode

#ifndef GL_EXT_texture_shared_exponent

#define GL_EXT_texture_shared_exponent
#ifndef GL_RGB9_E5_EXT
#define GL_RGB9_E5_EXT                                                  0x8C3D
#endif //GL_RGB9_E5_EXT
#ifndef GL_UNSIGNED_INT_5_9_9_9_REV_EXT
#define GL_UNSIGNED_INT_5_9_9_9_REV_EXT                                 0x8C3E
#endif //GL_UNSIGNED_INT_5_9_9_9_REV_EXT
#ifndef GL_TEXTURE_SHARED_SIZE_EXT
#define GL_TEXTURE_SHARED_SIZE_EXT                                      0x8C3F
#endif //GL_TEXTURE_SHARED_SIZE_EXT

#endif //GL_EXT_texture_shared_exponent

#ifndef GL_EXT_texture_snorm

#define GL_EXT_texture_snorm
#ifndef GL_ALPHA_SNORM
#define GL_ALPHA_SNORM                                                  0x9010
#endif //GL_ALPHA_SNORM
#ifndef GL_LUMINANCE_SNORM
#define GL_LUMINANCE_SNORM                                              0x9011
#endif //GL_LUMINANCE_SNORM
#ifndef GL_LUMINANCE_ALPHA_SNORM
#define GL_LUMINANCE_ALPHA_SNORM                                        0x9012
#endif //GL_LUMINANCE_ALPHA_SNORM
#ifndef GL_INTENSITY_SNORM
#define GL_INTENSITY_SNORM                                              0x9013
#endif //GL_INTENSITY_SNORM
#ifndef GL_ALPHA8_SNORM
#define GL_ALPHA8_SNORM                                                 0x9014
#endif //GL_ALPHA8_SNORM
#ifndef GL_LUMINANCE8_SNORM
#define GL_LUMINANCE8_SNORM                                             0x9015
#endif //GL_LUMINANCE8_SNORM
#ifndef GL_LUMINANCE8_ALPHA8_SNORM
#define GL_LUMINANCE8_ALPHA8_SNORM                                      0x9016
#endif //GL_LUMINANCE8_ALPHA8_SNORM
#ifndef GL_INTENSITY8_SNORM
#define GL_INTENSITY8_SNORM                                             0x9017
#endif //GL_INTENSITY8_SNORM
#ifndef GL_ALPHA16_SNORM
#define GL_ALPHA16_SNORM                                                0x9018
#endif //GL_ALPHA16_SNORM
#ifndef GL_LUMINANCE16_SNORM
#define GL_LUMINANCE16_SNORM                                            0x9019
#endif //GL_LUMINANCE16_SNORM
#ifndef GL_LUMINANCE16_ALPHA16_SNORM
#define GL_LUMINANCE16_ALPHA16_SNORM                                    0x901A
#endif //GL_LUMINANCE16_ALPHA16_SNORM
#ifndef GL_INTENSITY16_SNORM
#define GL_INTENSITY16_SNORM                                            0x901B
#endif //GL_INTENSITY16_SNORM

#endif //GL_EXT_texture_snorm

#ifndef GL_EXT_texture_swizzle

#define GL_EXT_texture_swizzle
#ifndef GL_TEXTURE_SWIZZLE_R_EXT
#define GL_TEXTURE_SWIZZLE_R_EXT                                        0x8E42
#endif //GL_TEXTURE_SWIZZLE_R_EXT
#ifndef GL_TEXTURE_SWIZZLE_G_EXT
#define GL_TEXTURE_SWIZZLE_G_EXT                                        0x8E43
#endif //GL_TEXTURE_SWIZZLE_G_EXT
#ifndef GL_TEXTURE_SWIZZLE_B_EXT
#define GL_TEXTURE_SWIZZLE_B_EXT                                        0x8E44
#endif //GL_TEXTURE_SWIZZLE_B_EXT
#ifndef GL_TEXTURE_SWIZZLE_A_EXT
#define GL_TEXTURE_SWIZZLE_A_EXT                                        0x8E45
#endif //GL_TEXTURE_SWIZZLE_A_EXT
#ifndef GL_TEXTURE_SWIZZLE_RGBA_EXT
#define GL_TEXTURE_SWIZZLE_RGBA_EXT                                     0x8E46
#endif //GL_TEXTURE_SWIZZLE_RGBA_EXT

#endif //GL_EXT_texture_swizzle

#ifndef GL_EXT_timer_query

#define GL_EXT_timer_query
#ifndef GL_TIME_ELAPSED_EXT
#define GL_TIME_ELAPSED_EXT                                             0x88BF
#endif //GL_TIME_ELAPSED_EXT

#endif //GL_EXT_timer_query


typedef void (*PFNGETQUERYOBJECTI64VEXTPROC_HPP)(GLuint id,GLenum pname,GLint64EXT *params);

static inline void GetQueryObjecti64vEXT(GLuint id,GLenum pname,GLint64EXT *params)
{
	static PFNGETQUERYOBJECTI64VEXTPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTI64VEXTPROC_HPP>(_impl::_get_proc_address("glGetQueryObjecti64vEXT","GL_EXT_timer_query"));
	 fn(id,pname,params);
}

typedef void (*PFNGETQUERYOBJECTUI64VEXTPROC_HPP)(GLuint id,GLenum pname,GLuint64EXT *params);

static inline void GetQueryObjectui64vEXT(GLuint id,GLenum pname,GLuint64EXT *params)
{
	static PFNGETQUERYOBJECTUI64VEXTPROC_HPP fn=reinterpret_cast<PFNGETQUERYOBJECTUI64VEXTPROC_HPP>(_impl::_get_proc_address("glGetQueryObjectui64vEXT","GL_EXT_timer_query"));
	 fn(id,pname,params);
}
#ifndef GL_EXT_transform_feedback

#define GL_EXT_transform_feedback

#endif //GL_EXT_transform_feedback


typedef void (*PFNBEGINTRANSFORMFEEDBACKEXTPROC_HPP)(GLenum primitiveMode);

static inline void BeginTransformFeedbackEXT(GLenum primitiveMode)
{
	static PFNBEGINTRANSFORMFEEDBACKEXTPROC_HPP fn=reinterpret_cast<PFNBEGINTRANSFORMFEEDBACKEXTPROC_HPP>(_impl::_get_proc_address("glBeginTransformFeedbackEXT","GL_EXT_transform_feedback"));
	 fn(primitiveMode);
}

typedef void (*PFNENDTRANSFORMFEEDBACKEXTPROC_HPP)();

static inline void EndTransformFeedbackEXT()
{
	static PFNENDTRANSFORMFEEDBACKEXTPROC_HPP fn=reinterpret_cast<PFNENDTRANSFORMFEEDBACKEXTPROC_HPP>(_impl::_get_proc_address("glEndTransformFeedbackEXT","GL_EXT_transform_feedback"));
	 fn();
}

typedef void (*PFNBINDBUFFERRANGEEXTPROC_HPP)(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);

static inline void BindBufferRangeEXT(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)
{
	static PFNBINDBUFFERRANGEEXTPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERRANGEEXTPROC_HPP>(_impl::_get_proc_address("glBindBufferRangeEXT","GL_EXT_transform_feedback"));
	 fn(target,index,buffer,offset,size);
}

typedef void (*PFNBINDBUFFEROFFSETEXTPROC_HPP)(GLenum target,GLuint index,GLuint buffer,GLintptr offset);

static inline void BindBufferOffsetEXT(GLenum target,GLuint index,GLuint buffer,GLintptr offset)
{
	static PFNBINDBUFFEROFFSETEXTPROC_HPP fn=reinterpret_cast<PFNBINDBUFFEROFFSETEXTPROC_HPP>(_impl::_get_proc_address("glBindBufferOffsetEXT","GL_EXT_transform_feedback"));
	 fn(target,index,buffer,offset);
}

typedef void (*PFNBINDBUFFERBASEEXTPROC_HPP)(GLenum target,GLuint index,GLuint buffer);

static inline void BindBufferBaseEXT(GLenum target,GLuint index,GLuint buffer)
{
	static PFNBINDBUFFERBASEEXTPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERBASEEXTPROC_HPP>(_impl::_get_proc_address("glBindBufferBaseEXT","GL_EXT_transform_feedback"));
	 fn(target,index,buffer);
}

typedef void (*PFNTRANSFORMFEEDBACKVARYINGSEXTPROC_HPP)(GLuint program,GLsizei count,const GLchar* *varyings,GLenum bufferMode);

static inline void TransformFeedbackVaryingsEXT(GLuint program,GLsizei count,const GLchar* *varyings,GLenum bufferMode)
{
	static PFNTRANSFORMFEEDBACKVARYINGSEXTPROC_HPP fn=reinterpret_cast<PFNTRANSFORMFEEDBACKVARYINGSEXTPROC_HPP>(_impl::_get_proc_address("glTransformFeedbackVaryingsEXT","GL_EXT_transform_feedback"));
	 fn(program,count,varyings,bufferMode);
}

typedef void (*PFNGETTRANSFORMFEEDBACKVARYINGEXTPROC_HPP)(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name);

static inline void GetTransformFeedbackVaryingEXT(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name)
{
	static PFNGETTRANSFORMFEEDBACKVARYINGEXTPROC_HPP fn=reinterpret_cast<PFNGETTRANSFORMFEEDBACKVARYINGEXTPROC_HPP>(_impl::_get_proc_address("glGetTransformFeedbackVaryingEXT","GL_EXT_transform_feedback"));
	 fn(program,index,bufSize,length,size,type,name);
}
#ifndef GL_EXT_unpack_subimage

#define GL_EXT_unpack_subimage
#ifndef GL_UNPACK_ROW_LENGTH
#define GL_UNPACK_ROW_LENGTH                                            0x0CF2
#endif //GL_UNPACK_ROW_LENGTH
#ifndef GL_UNPACK_SKIP_ROWS
#define GL_UNPACK_SKIP_ROWS                                             0x0CF3
#endif //GL_UNPACK_SKIP_ROWS
#ifndef GL_UNPACK_SKIP_PIXELS
#define GL_UNPACK_SKIP_PIXELS                                           0x0CF4
#endif //GL_UNPACK_SKIP_PIXELS

#endif //GL_EXT_unpack_subimage

#ifndef GL_EXT_vertex_array

#define GL_EXT_vertex_array
#ifndef GL_VERTEX_ARRAY_EXT
#define GL_VERTEX_ARRAY_EXT                                             0x8074
#endif //GL_VERTEX_ARRAY_EXT
#ifndef GL_NORMAL_ARRAY_EXT
#define GL_NORMAL_ARRAY_EXT                                             0x8075
#endif //GL_NORMAL_ARRAY_EXT
#ifndef GL_COLOR_ARRAY_EXT
#define GL_COLOR_ARRAY_EXT                                              0x8076
#endif //GL_COLOR_ARRAY_EXT
#ifndef GL_INDEX_ARRAY_EXT
#define GL_INDEX_ARRAY_EXT                                              0x8077
#endif //GL_INDEX_ARRAY_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_EXT
#define GL_TEXTURE_COORD_ARRAY_EXT                                      0x8078
#endif //GL_TEXTURE_COORD_ARRAY_EXT
#ifndef GL_EDGE_FLAG_ARRAY_EXT
#define GL_EDGE_FLAG_ARRAY_EXT                                          0x8079
#endif //GL_EDGE_FLAG_ARRAY_EXT
#ifndef GL_VERTEX_ARRAY_SIZE_EXT
#define GL_VERTEX_ARRAY_SIZE_EXT                                        0x807A
#endif //GL_VERTEX_ARRAY_SIZE_EXT
#ifndef GL_VERTEX_ARRAY_TYPE_EXT
#define GL_VERTEX_ARRAY_TYPE_EXT                                        0x807B
#endif //GL_VERTEX_ARRAY_TYPE_EXT
#ifndef GL_VERTEX_ARRAY_STRIDE_EXT
#define GL_VERTEX_ARRAY_STRIDE_EXT                                      0x807C
#endif //GL_VERTEX_ARRAY_STRIDE_EXT
#ifndef GL_VERTEX_ARRAY_COUNT_EXT
#define GL_VERTEX_ARRAY_COUNT_EXT                                       0x807D
#endif //GL_VERTEX_ARRAY_COUNT_EXT
#ifndef GL_NORMAL_ARRAY_TYPE_EXT
#define GL_NORMAL_ARRAY_TYPE_EXT                                        0x807E
#endif //GL_NORMAL_ARRAY_TYPE_EXT
#ifndef GL_NORMAL_ARRAY_STRIDE_EXT
#define GL_NORMAL_ARRAY_STRIDE_EXT                                      0x807F
#endif //GL_NORMAL_ARRAY_STRIDE_EXT
#ifndef GL_NORMAL_ARRAY_COUNT_EXT
#define GL_NORMAL_ARRAY_COUNT_EXT                                       0x8080
#endif //GL_NORMAL_ARRAY_COUNT_EXT
#ifndef GL_COLOR_ARRAY_SIZE_EXT
#define GL_COLOR_ARRAY_SIZE_EXT                                         0x8081
#endif //GL_COLOR_ARRAY_SIZE_EXT
#ifndef GL_COLOR_ARRAY_TYPE_EXT
#define GL_COLOR_ARRAY_TYPE_EXT                                         0x8082
#endif //GL_COLOR_ARRAY_TYPE_EXT
#ifndef GL_COLOR_ARRAY_STRIDE_EXT
#define GL_COLOR_ARRAY_STRIDE_EXT                                       0x8083
#endif //GL_COLOR_ARRAY_STRIDE_EXT
#ifndef GL_COLOR_ARRAY_COUNT_EXT
#define GL_COLOR_ARRAY_COUNT_EXT                                        0x8084
#endif //GL_COLOR_ARRAY_COUNT_EXT
#ifndef GL_INDEX_ARRAY_TYPE_EXT
#define GL_INDEX_ARRAY_TYPE_EXT                                         0x8085
#endif //GL_INDEX_ARRAY_TYPE_EXT
#ifndef GL_INDEX_ARRAY_STRIDE_EXT
#define GL_INDEX_ARRAY_STRIDE_EXT                                       0x8086
#endif //GL_INDEX_ARRAY_STRIDE_EXT
#ifndef GL_INDEX_ARRAY_COUNT_EXT
#define GL_INDEX_ARRAY_COUNT_EXT                                        0x8087
#endif //GL_INDEX_ARRAY_COUNT_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_SIZE_EXT
#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT                                 0x8088
#endif //GL_TEXTURE_COORD_ARRAY_SIZE_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_TYPE_EXT
#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT                                 0x8089
#endif //GL_TEXTURE_COORD_ARRAY_TYPE_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_STRIDE_EXT
#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT                               0x808A
#endif //GL_TEXTURE_COORD_ARRAY_STRIDE_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_COUNT_EXT
#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT                                0x808B
#endif //GL_TEXTURE_COORD_ARRAY_COUNT_EXT
#ifndef GL_EDGE_FLAG_ARRAY_STRIDE_EXT
#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT                                   0x808C
#endif //GL_EDGE_FLAG_ARRAY_STRIDE_EXT
#ifndef GL_EDGE_FLAG_ARRAY_COUNT_EXT
#define GL_EDGE_FLAG_ARRAY_COUNT_EXT                                    0x808D
#endif //GL_EDGE_FLAG_ARRAY_COUNT_EXT
#ifndef GL_VERTEX_ARRAY_POINTER_EXT
#define GL_VERTEX_ARRAY_POINTER_EXT                                     0x808E
#endif //GL_VERTEX_ARRAY_POINTER_EXT
#ifndef GL_NORMAL_ARRAY_POINTER_EXT
#define GL_NORMAL_ARRAY_POINTER_EXT                                     0x808F
#endif //GL_NORMAL_ARRAY_POINTER_EXT
#ifndef GL_COLOR_ARRAY_POINTER_EXT
#define GL_COLOR_ARRAY_POINTER_EXT                                      0x8090
#endif //GL_COLOR_ARRAY_POINTER_EXT
#ifndef GL_INDEX_ARRAY_POINTER_EXT
#define GL_INDEX_ARRAY_POINTER_EXT                                      0x8091
#endif //GL_INDEX_ARRAY_POINTER_EXT
#ifndef GL_TEXTURE_COORD_ARRAY_POINTER_EXT
#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT                              0x8092
#endif //GL_TEXTURE_COORD_ARRAY_POINTER_EXT
#ifndef GL_EDGE_FLAG_ARRAY_POINTER_EXT
#define GL_EDGE_FLAG_ARRAY_POINTER_EXT                                  0x8093
#endif //GL_EDGE_FLAG_ARRAY_POINTER_EXT

#endif //GL_EXT_vertex_array


typedef void (*PFNARRAYELEMENTEXTPROC_HPP)(GLint i);

static inline void ArrayElementEXT(GLint i)
{
	static PFNARRAYELEMENTEXTPROC_HPP fn=reinterpret_cast<PFNARRAYELEMENTEXTPROC_HPP>(_impl::_get_proc_address("glArrayElementEXT","GL_EXT_vertex_array"));
	 fn(i);
}

typedef void (*PFNCOLORPOINTEREXTPROC_HPP)(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer);

static inline void ColorPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer)
{
	static PFNCOLORPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNCOLORPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glColorPointerEXT","GL_EXT_vertex_array"));
	 fn(size,type,stride,count,pointer);
}

typedef void (*PFNDRAWARRAYSEXTPROC_HPP)(GLenum mode,GLint first,GLsizei count);

static inline void DrawArraysEXT(GLenum mode,GLint first,GLsizei count)
{
	static PFNDRAWARRAYSEXTPROC_HPP fn=reinterpret_cast<PFNDRAWARRAYSEXTPROC_HPP>(_impl::_get_proc_address("glDrawArraysEXT","GL_EXT_vertex_array"));
	 fn(mode,first,count);
}

typedef void (*PFNEDGEFLAGPOINTEREXTPROC_HPP)(GLsizei stride,GLsizei count,const GLboolean *pointer);

static inline void EdgeFlagPointerEXT(GLsizei stride,GLsizei count,const GLboolean *pointer)
{
	static PFNEDGEFLAGPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNEDGEFLAGPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glEdgeFlagPointerEXT","GL_EXT_vertex_array"));
	 fn(stride,count,pointer);
}

typedef void (*PFNGETPOINTERVEXTPROC_HPP)(GLenum pname,GLvoid* *params);

static inline void GetPointervEXT(GLenum pname,GLvoid* *params)
{
	static PFNGETPOINTERVEXTPROC_HPP fn=reinterpret_cast<PFNGETPOINTERVEXTPROC_HPP>(_impl::_get_proc_address("glGetPointervEXT","GL_EXT_vertex_array"));
	 fn(pname,params);
}

typedef void (*PFNINDEXPOINTEREXTPROC_HPP)(GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer);

static inline void IndexPointerEXT(GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer)
{
	static PFNINDEXPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNINDEXPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glIndexPointerEXT","GL_EXT_vertex_array"));
	 fn(type,stride,count,pointer);
}

typedef void (*PFNNORMALPOINTEREXTPROC_HPP)(GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer);

static inline void NormalPointerEXT(GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer)
{
	static PFNNORMALPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNNORMALPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glNormalPointerEXT","GL_EXT_vertex_array"));
	 fn(type,stride,count,pointer);
}

typedef void (*PFNTEXCOORDPOINTEREXTPROC_HPP)(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer);

static inline void TexCoordPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer)
{
	static PFNTEXCOORDPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNTEXCOORDPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glTexCoordPointerEXT","GL_EXT_vertex_array"));
	 fn(size,type,stride,count,pointer);
}

typedef void (*PFNVERTEXPOINTEREXTPROC_HPP)(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer);

static inline void VertexPointerEXT(GLint size,GLenum type,GLsizei stride,GLsizei count,const GLvoid *pointer)
{
	static PFNVERTEXPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glVertexPointerEXT","GL_EXT_vertex_array"));
	 fn(size,type,stride,count,pointer);
}
#ifndef GL_EXT_vertex_attrib_64bit

#define GL_EXT_vertex_attrib_64bit
#ifndef GL_DOUBLE_MAT2_EXT
#define GL_DOUBLE_MAT2_EXT                                              0x8F46
#endif //GL_DOUBLE_MAT2_EXT
#ifndef GL_DOUBLE_MAT3_EXT
#define GL_DOUBLE_MAT3_EXT                                              0x8F47
#endif //GL_DOUBLE_MAT3_EXT
#ifndef GL_DOUBLE_MAT4_EXT
#define GL_DOUBLE_MAT4_EXT                                              0x8F48
#endif //GL_DOUBLE_MAT4_EXT
#ifndef GL_DOUBLE_MAT2x3_EXT
#define GL_DOUBLE_MAT2x3_EXT                                            0x8F49
#endif //GL_DOUBLE_MAT2x3_EXT
#ifndef GL_DOUBLE_MAT2x4_EXT
#define GL_DOUBLE_MAT2x4_EXT                                            0x8F4A
#endif //GL_DOUBLE_MAT2x4_EXT
#ifndef GL_DOUBLE_MAT3x2_EXT
#define GL_DOUBLE_MAT3x2_EXT                                            0x8F4B
#endif //GL_DOUBLE_MAT3x2_EXT
#ifndef GL_DOUBLE_MAT3x4_EXT
#define GL_DOUBLE_MAT3x4_EXT                                            0x8F4C
#endif //GL_DOUBLE_MAT3x4_EXT
#ifndef GL_DOUBLE_MAT4x2_EXT
#define GL_DOUBLE_MAT4x2_EXT                                            0x8F4D
#endif //GL_DOUBLE_MAT4x2_EXT
#ifndef GL_DOUBLE_MAT4x3_EXT
#define GL_DOUBLE_MAT4x3_EXT                                            0x8F4E
#endif //GL_DOUBLE_MAT4x3_EXT
#ifndef GL_DOUBLE_VEC2_EXT
#define GL_DOUBLE_VEC2_EXT                                              0x8FFC
#endif //GL_DOUBLE_VEC2_EXT
#ifndef GL_DOUBLE_VEC3_EXT
#define GL_DOUBLE_VEC3_EXT                                              0x8FFD
#endif //GL_DOUBLE_VEC3_EXT
#ifndef GL_DOUBLE_VEC4_EXT
#define GL_DOUBLE_VEC4_EXT                                              0x8FFE
#endif //GL_DOUBLE_VEC4_EXT

#endif //GL_EXT_vertex_attrib_64bit


typedef void (*PFNVERTEXATTRIBL1DEXTPROC_HPP)(GLuint index,GLdouble x);

static inline void VertexAttribL1dEXT(GLuint index,GLdouble x)
{
	static PFNVERTEXATTRIBL1DEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1DEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1dEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBL2DEXTPROC_HPP)(GLuint index,GLdouble x,GLdouble y);

static inline void VertexAttribL2dEXT(GLuint index,GLdouble x,GLdouble y)
{
	static PFNVERTEXATTRIBL2DEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2DEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2dEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBL3DEXTPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexAttribL3dEXT(GLuint index,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXATTRIBL3DEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3DEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3dEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBL4DEXTPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexAttribL4dEXT(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXATTRIBL4DEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4DEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4dEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBL1DVEXTPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL1dvEXT(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL1DVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1DVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1dvEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL2DVEXTPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL2dvEXT(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL2DVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2DVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2dvEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL3DVEXTPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL3dvEXT(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL3DVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3DVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3dvEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL4DVEXTPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttribL4dvEXT(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIBL4DVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4DVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4dvEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBLPOINTEREXTPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribLPointerEXT(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBLPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBLPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribLPointerEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,size,type,stride,pointer);
}

typedef void (*PFNGETVERTEXATTRIBLDVEXTPROC_HPP)(GLuint index,GLenum pname,GLdouble *params);

static inline void GetVertexAttribLdvEXT(GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETVERTEXATTRIBLDVEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBLDVEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribLdvEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(index,pname,params);
}

typedef void (*PFNVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC_HPP)(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset);

static inline void VertexArrayVertexAttribLOffsetEXT(GLuint vaobj,GLuint buffer,GLuint index,GLint size,GLenum type,GLsizei stride,GLintptr offset)
{
	static PFNVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC_HPP>(_impl::_get_proc_address("glVertexArrayVertexAttribLOffsetEXT","GL_EXT_vertex_attrib_64bit"));
	 fn(vaobj,buffer,index,size,type,stride,offset);
}
#ifndef GL_EXT_vertex_shader

#define GL_EXT_vertex_shader
#ifndef GL_VERTEX_SHADER_EXT
#define GL_VERTEX_SHADER_EXT                                            0x8780
#endif //GL_VERTEX_SHADER_EXT
#ifndef GL_VERTEX_SHADER_BINDING_EXT
#define GL_VERTEX_SHADER_BINDING_EXT                                    0x8781
#endif //GL_VERTEX_SHADER_BINDING_EXT
#ifndef GL_OP_INDEX_EXT
#define GL_OP_INDEX_EXT                                                 0x8782
#endif //GL_OP_INDEX_EXT
#ifndef GL_OP_NEGATE_EXT
#define GL_OP_NEGATE_EXT                                                0x8783
#endif //GL_OP_NEGATE_EXT
#ifndef GL_OP_DOT3_EXT
#define GL_OP_DOT3_EXT                                                  0x8784
#endif //GL_OP_DOT3_EXT
#ifndef GL_OP_DOT4_EXT
#define GL_OP_DOT4_EXT                                                  0x8785
#endif //GL_OP_DOT4_EXT
#ifndef GL_OP_MUL_EXT
#define GL_OP_MUL_EXT                                                   0x8786
#endif //GL_OP_MUL_EXT
#ifndef GL_OP_ADD_EXT
#define GL_OP_ADD_EXT                                                   0x8787
#endif //GL_OP_ADD_EXT
#ifndef GL_OP_MADD_EXT
#define GL_OP_MADD_EXT                                                  0x8788
#endif //GL_OP_MADD_EXT
#ifndef GL_OP_FRAC_EXT
#define GL_OP_FRAC_EXT                                                  0x8789
#endif //GL_OP_FRAC_EXT
#ifndef GL_OP_MAX_EXT
#define GL_OP_MAX_EXT                                                   0x878A
#endif //GL_OP_MAX_EXT
#ifndef GL_OP_MIN_EXT
#define GL_OP_MIN_EXT                                                   0x878B
#endif //GL_OP_MIN_EXT
#ifndef GL_OP_SET_GE_EXT
#define GL_OP_SET_GE_EXT                                                0x878C
#endif //GL_OP_SET_GE_EXT
#ifndef GL_OP_SET_LT_EXT
#define GL_OP_SET_LT_EXT                                                0x878D
#endif //GL_OP_SET_LT_EXT
#ifndef GL_OP_CLAMP_EXT
#define GL_OP_CLAMP_EXT                                                 0x878E
#endif //GL_OP_CLAMP_EXT
#ifndef GL_OP_FLOOR_EXT
#define GL_OP_FLOOR_EXT                                                 0x878F
#endif //GL_OP_FLOOR_EXT
#ifndef GL_OP_ROUND_EXT
#define GL_OP_ROUND_EXT                                                 0x8790
#endif //GL_OP_ROUND_EXT
#ifndef GL_OP_EXP_BASE_2_EXT
#define GL_OP_EXP_BASE_2_EXT                                            0x8791
#endif //GL_OP_EXP_BASE_2_EXT
#ifndef GL_OP_LOG_BASE_2_EXT
#define GL_OP_LOG_BASE_2_EXT                                            0x8792
#endif //GL_OP_LOG_BASE_2_EXT
#ifndef GL_OP_POWER_EXT
#define GL_OP_POWER_EXT                                                 0x8793
#endif //GL_OP_POWER_EXT
#ifndef GL_OP_RECIP_EXT
#define GL_OP_RECIP_EXT                                                 0x8794
#endif //GL_OP_RECIP_EXT
#ifndef GL_OP_RECIP_SQRT_EXT
#define GL_OP_RECIP_SQRT_EXT                                            0x8795
#endif //GL_OP_RECIP_SQRT_EXT
#ifndef GL_OP_SUB_EXT
#define GL_OP_SUB_EXT                                                   0x8796
#endif //GL_OP_SUB_EXT
#ifndef GL_OP_CROSS_PRODUCT_EXT
#define GL_OP_CROSS_PRODUCT_EXT                                         0x8797
#endif //GL_OP_CROSS_PRODUCT_EXT
#ifndef GL_OP_MULTIPLY_MATRIX_EXT
#define GL_OP_MULTIPLY_MATRIX_EXT                                       0x8798
#endif //GL_OP_MULTIPLY_MATRIX_EXT
#ifndef GL_OP_MOV_EXT
#define GL_OP_MOV_EXT                                                   0x8799
#endif //GL_OP_MOV_EXT
#ifndef GL_OUTPUT_VERTEX_EXT
#define GL_OUTPUT_VERTEX_EXT                                            0x879A
#endif //GL_OUTPUT_VERTEX_EXT
#ifndef GL_OUTPUT_COLOR0_EXT
#define GL_OUTPUT_COLOR0_EXT                                            0x879B
#endif //GL_OUTPUT_COLOR0_EXT
#ifndef GL_OUTPUT_COLOR1_EXT
#define GL_OUTPUT_COLOR1_EXT                                            0x879C
#endif //GL_OUTPUT_COLOR1_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD0_EXT
#define GL_OUTPUT_TEXTURE_COORD0_EXT                                    0x879D
#endif //GL_OUTPUT_TEXTURE_COORD0_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD1_EXT
#define GL_OUTPUT_TEXTURE_COORD1_EXT                                    0x879E
#endif //GL_OUTPUT_TEXTURE_COORD1_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD2_EXT
#define GL_OUTPUT_TEXTURE_COORD2_EXT                                    0x879F
#endif //GL_OUTPUT_TEXTURE_COORD2_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD3_EXT
#define GL_OUTPUT_TEXTURE_COORD3_EXT                                    0x87A0
#endif //GL_OUTPUT_TEXTURE_COORD3_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD4_EXT
#define GL_OUTPUT_TEXTURE_COORD4_EXT                                    0x87A1
#endif //GL_OUTPUT_TEXTURE_COORD4_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD5_EXT
#define GL_OUTPUT_TEXTURE_COORD5_EXT                                    0x87A2
#endif //GL_OUTPUT_TEXTURE_COORD5_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD6_EXT
#define GL_OUTPUT_TEXTURE_COORD6_EXT                                    0x87A3
#endif //GL_OUTPUT_TEXTURE_COORD6_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD7_EXT
#define GL_OUTPUT_TEXTURE_COORD7_EXT                                    0x87A4
#endif //GL_OUTPUT_TEXTURE_COORD7_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD8_EXT
#define GL_OUTPUT_TEXTURE_COORD8_EXT                                    0x87A5
#endif //GL_OUTPUT_TEXTURE_COORD8_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD9_EXT
#define GL_OUTPUT_TEXTURE_COORD9_EXT                                    0x87A6
#endif //GL_OUTPUT_TEXTURE_COORD9_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD10_EXT
#define GL_OUTPUT_TEXTURE_COORD10_EXT                                   0x87A7
#endif //GL_OUTPUT_TEXTURE_COORD10_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD11_EXT
#define GL_OUTPUT_TEXTURE_COORD11_EXT                                   0x87A8
#endif //GL_OUTPUT_TEXTURE_COORD11_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD12_EXT
#define GL_OUTPUT_TEXTURE_COORD12_EXT                                   0x87A9
#endif //GL_OUTPUT_TEXTURE_COORD12_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD13_EXT
#define GL_OUTPUT_TEXTURE_COORD13_EXT                                   0x87AA
#endif //GL_OUTPUT_TEXTURE_COORD13_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD14_EXT
#define GL_OUTPUT_TEXTURE_COORD14_EXT                                   0x87AB
#endif //GL_OUTPUT_TEXTURE_COORD14_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD15_EXT
#define GL_OUTPUT_TEXTURE_COORD15_EXT                                   0x87AC
#endif //GL_OUTPUT_TEXTURE_COORD15_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD16_EXT
#define GL_OUTPUT_TEXTURE_COORD16_EXT                                   0x87AD
#endif //GL_OUTPUT_TEXTURE_COORD16_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD17_EXT
#define GL_OUTPUT_TEXTURE_COORD17_EXT                                   0x87AE
#endif //GL_OUTPUT_TEXTURE_COORD17_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD18_EXT
#define GL_OUTPUT_TEXTURE_COORD18_EXT                                   0x87AF
#endif //GL_OUTPUT_TEXTURE_COORD18_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD19_EXT
#define GL_OUTPUT_TEXTURE_COORD19_EXT                                   0x87B0
#endif //GL_OUTPUT_TEXTURE_COORD19_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD20_EXT
#define GL_OUTPUT_TEXTURE_COORD20_EXT                                   0x87B1
#endif //GL_OUTPUT_TEXTURE_COORD20_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD21_EXT
#define GL_OUTPUT_TEXTURE_COORD21_EXT                                   0x87B2
#endif //GL_OUTPUT_TEXTURE_COORD21_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD22_EXT
#define GL_OUTPUT_TEXTURE_COORD22_EXT                                   0x87B3
#endif //GL_OUTPUT_TEXTURE_COORD22_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD23_EXT
#define GL_OUTPUT_TEXTURE_COORD23_EXT                                   0x87B4
#endif //GL_OUTPUT_TEXTURE_COORD23_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD24_EXT
#define GL_OUTPUT_TEXTURE_COORD24_EXT                                   0x87B5
#endif //GL_OUTPUT_TEXTURE_COORD24_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD25_EXT
#define GL_OUTPUT_TEXTURE_COORD25_EXT                                   0x87B6
#endif //GL_OUTPUT_TEXTURE_COORD25_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD26_EXT
#define GL_OUTPUT_TEXTURE_COORD26_EXT                                   0x87B7
#endif //GL_OUTPUT_TEXTURE_COORD26_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD27_EXT
#define GL_OUTPUT_TEXTURE_COORD27_EXT                                   0x87B8
#endif //GL_OUTPUT_TEXTURE_COORD27_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD28_EXT
#define GL_OUTPUT_TEXTURE_COORD28_EXT                                   0x87B9
#endif //GL_OUTPUT_TEXTURE_COORD28_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD29_EXT
#define GL_OUTPUT_TEXTURE_COORD29_EXT                                   0x87BA
#endif //GL_OUTPUT_TEXTURE_COORD29_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD30_EXT
#define GL_OUTPUT_TEXTURE_COORD30_EXT                                   0x87BB
#endif //GL_OUTPUT_TEXTURE_COORD30_EXT
#ifndef GL_OUTPUT_TEXTURE_COORD31_EXT
#define GL_OUTPUT_TEXTURE_COORD31_EXT                                   0x87BC
#endif //GL_OUTPUT_TEXTURE_COORD31_EXT
#ifndef GL_OUTPUT_FOG_EXT
#define GL_OUTPUT_FOG_EXT                                               0x87BD
#endif //GL_OUTPUT_FOG_EXT
#ifndef GL_SCALAR_EXT
#define GL_SCALAR_EXT                                                   0x87BE
#endif //GL_SCALAR_EXT
#ifndef GL_VECTOR_EXT
#define GL_VECTOR_EXT                                                   0x87BF
#endif //GL_VECTOR_EXT
#ifndef GL_MATRIX_EXT
#define GL_MATRIX_EXT                                                   0x87C0
#endif //GL_MATRIX_EXT
#ifndef GL_VARIANT_EXT
#define GL_VARIANT_EXT                                                  0x87C1
#endif //GL_VARIANT_EXT
#ifndef GL_INVARIANT_EXT
#define GL_INVARIANT_EXT                                                0x87C2
#endif //GL_INVARIANT_EXT
#ifndef GL_LOCAL_CONSTANT_EXT
#define GL_LOCAL_CONSTANT_EXT                                           0x87C3
#endif //GL_LOCAL_CONSTANT_EXT
#ifndef GL_LOCAL_EXT
#define GL_LOCAL_EXT                                                    0x87C4
#endif //GL_LOCAL_EXT
#ifndef GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT
#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT                           0x87C5
#endif //GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT
#ifndef GL_MAX_VERTEX_SHADER_VARIANTS_EXT
#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT                               0x87C6
#endif //GL_MAX_VERTEX_SHADER_VARIANTS_EXT
#ifndef GL_MAX_VERTEX_SHADER_INVARIANTS_EXT
#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT                             0x87C7
#endif //GL_MAX_VERTEX_SHADER_INVARIANTS_EXT
#ifndef GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                        0x87C8
#endif //GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#ifndef GL_MAX_VERTEX_SHADER_LOCALS_EXT
#define GL_MAX_VERTEX_SHADER_LOCALS_EXT                                 0x87C9
#endif //GL_MAX_VERTEX_SHADER_LOCALS_EXT
#ifndef GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT
#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT                 0x87CA
#endif //GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT
#ifndef GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT
#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT                     0x87CB
#endif //GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT
#ifndef GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT              0x87CC
#endif //GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#ifndef GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT
#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT                   0x87CD
#endif //GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT
#ifndef GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT
#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT                       0x87CE
#endif //GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT
#ifndef GL_VERTEX_SHADER_INSTRUCTIONS_EXT
#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT                               0x87CF
#endif //GL_VERTEX_SHADER_INSTRUCTIONS_EXT
#ifndef GL_VERTEX_SHADER_VARIANTS_EXT
#define GL_VERTEX_SHADER_VARIANTS_EXT                                   0x87D0
#endif //GL_VERTEX_SHADER_VARIANTS_EXT
#ifndef GL_VERTEX_SHADER_INVARIANTS_EXT
#define GL_VERTEX_SHADER_INVARIANTS_EXT                                 0x87D1
#endif //GL_VERTEX_SHADER_INVARIANTS_EXT
#ifndef GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT                            0x87D2
#endif //GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT
#ifndef GL_VERTEX_SHADER_LOCALS_EXT
#define GL_VERTEX_SHADER_LOCALS_EXT                                     0x87D3
#endif //GL_VERTEX_SHADER_LOCALS_EXT
#ifndef GL_VERTEX_SHADER_OPTIMIZED_EXT
#define GL_VERTEX_SHADER_OPTIMIZED_EXT                                  0x87D4
#endif //GL_VERTEX_SHADER_OPTIMIZED_EXT
#ifndef GL_X_EXT
#define GL_X_EXT                                                        0x87D5
#endif //GL_X_EXT
#ifndef GL_Y_EXT
#define GL_Y_EXT                                                        0x87D6
#endif //GL_Y_EXT
#ifndef GL_Z_EXT
#define GL_Z_EXT                                                        0x87D7
#endif //GL_Z_EXT
#ifndef GL_W_EXT
#define GL_W_EXT                                                        0x87D8
#endif //GL_W_EXT
#ifndef GL_NEGATIVE_X_EXT
#define GL_NEGATIVE_X_EXT                                               0x87D9
#endif //GL_NEGATIVE_X_EXT
#ifndef GL_NEGATIVE_Y_EXT
#define GL_NEGATIVE_Y_EXT                                               0x87DA
#endif //GL_NEGATIVE_Y_EXT
#ifndef GL_NEGATIVE_Z_EXT
#define GL_NEGATIVE_Z_EXT                                               0x87DB
#endif //GL_NEGATIVE_Z_EXT
#ifndef GL_NEGATIVE_W_EXT
#define GL_NEGATIVE_W_EXT                                               0x87DC
#endif //GL_NEGATIVE_W_EXT
#ifndef GL_ZERO_EXT
#define GL_ZERO_EXT                                                     0x87DD
#endif //GL_ZERO_EXT
#ifndef GL_ONE_EXT
#define GL_ONE_EXT                                                      0x87DE
#endif //GL_ONE_EXT
#ifndef GL_NEGATIVE_ONE_EXT
#define GL_NEGATIVE_ONE_EXT                                             0x87DF
#endif //GL_NEGATIVE_ONE_EXT
#ifndef GL_NORMALIZED_RANGE_EXT
#define GL_NORMALIZED_RANGE_EXT                                         0x87E0
#endif //GL_NORMALIZED_RANGE_EXT
#ifndef GL_FULL_RANGE_EXT
#define GL_FULL_RANGE_EXT                                               0x87E1
#endif //GL_FULL_RANGE_EXT
#ifndef GL_CURRENT_VERTEX_EXT
#define GL_CURRENT_VERTEX_EXT                                           0x87E2
#endif //GL_CURRENT_VERTEX_EXT
#ifndef GL_MVP_MATRIX_EXT
#define GL_MVP_MATRIX_EXT                                               0x87E3
#endif //GL_MVP_MATRIX_EXT
#ifndef GL_VARIANT_VALUE_EXT
#define GL_VARIANT_VALUE_EXT                                            0x87E4
#endif //GL_VARIANT_VALUE_EXT
#ifndef GL_VARIANT_DATATYPE_EXT
#define GL_VARIANT_DATATYPE_EXT                                         0x87E5
#endif //GL_VARIANT_DATATYPE_EXT
#ifndef GL_VARIANT_ARRAY_STRIDE_EXT
#define GL_VARIANT_ARRAY_STRIDE_EXT                                     0x87E6
#endif //GL_VARIANT_ARRAY_STRIDE_EXT
#ifndef GL_VARIANT_ARRAY_TYPE_EXT
#define GL_VARIANT_ARRAY_TYPE_EXT                                       0x87E7
#endif //GL_VARIANT_ARRAY_TYPE_EXT
#ifndef GL_VARIANT_ARRAY_EXT
#define GL_VARIANT_ARRAY_EXT                                            0x87E8
#endif //GL_VARIANT_ARRAY_EXT
#ifndef GL_VARIANT_ARRAY_POINTER_EXT
#define GL_VARIANT_ARRAY_POINTER_EXT                                    0x87E9
#endif //GL_VARIANT_ARRAY_POINTER_EXT
#ifndef GL_INVARIANT_VALUE_EXT
#define GL_INVARIANT_VALUE_EXT                                          0x87EA
#endif //GL_INVARIANT_VALUE_EXT
#ifndef GL_INVARIANT_DATATYPE_EXT
#define GL_INVARIANT_DATATYPE_EXT                                       0x87EB
#endif //GL_INVARIANT_DATATYPE_EXT
#ifndef GL_LOCAL_CONSTANT_VALUE_EXT
#define GL_LOCAL_CONSTANT_VALUE_EXT                                     0x87EC
#endif //GL_LOCAL_CONSTANT_VALUE_EXT
#ifndef GL_LOCAL_CONSTANT_DATATYPE_EXT
#define GL_LOCAL_CONSTANT_DATATYPE_EXT                                  0x87ED
#endif //GL_LOCAL_CONSTANT_DATATYPE_EXT

#endif //GL_EXT_vertex_shader


typedef void (*PFNBEGINVERTEXSHADEREXTPROC_HPP)();

static inline void BeginVertexShaderEXT()
{
	static PFNBEGINVERTEXSHADEREXTPROC_HPP fn=reinterpret_cast<PFNBEGINVERTEXSHADEREXTPROC_HPP>(_impl::_get_proc_address("glBeginVertexShaderEXT","GL_EXT_vertex_shader"));
	 fn();
}

typedef void (*PFNENDVERTEXSHADEREXTPROC_HPP)();

static inline void EndVertexShaderEXT()
{
	static PFNENDVERTEXSHADEREXTPROC_HPP fn=reinterpret_cast<PFNENDVERTEXSHADEREXTPROC_HPP>(_impl::_get_proc_address("glEndVertexShaderEXT","GL_EXT_vertex_shader"));
	 fn();
}

typedef void (*PFNBINDVERTEXSHADEREXTPROC_HPP)(GLuint id);

static inline void BindVertexShaderEXT(GLuint id)
{
	static PFNBINDVERTEXSHADEREXTPROC_HPP fn=reinterpret_cast<PFNBINDVERTEXSHADEREXTPROC_HPP>(_impl::_get_proc_address("glBindVertexShaderEXT","GL_EXT_vertex_shader"));
	 fn(id);
}

typedef GLuint (*PFNGENVERTEXSHADERSEXTPROC_HPP)(GLuint range);

static inline GLuint GenVertexShadersEXT(GLuint range)
{
	static PFNGENVERTEXSHADERSEXTPROC_HPP fn=reinterpret_cast<PFNGENVERTEXSHADERSEXTPROC_HPP>(_impl::_get_proc_address("glGenVertexShadersEXT","GL_EXT_vertex_shader"));
	return fn(range);
}

typedef void (*PFNDELETEVERTEXSHADEREXTPROC_HPP)(GLuint id);

static inline void DeleteVertexShaderEXT(GLuint id)
{
	static PFNDELETEVERTEXSHADEREXTPROC_HPP fn=reinterpret_cast<PFNDELETEVERTEXSHADEREXTPROC_HPP>(_impl::_get_proc_address("glDeleteVertexShaderEXT","GL_EXT_vertex_shader"));
	 fn(id);
}

typedef void (*PFNSHADEROP1EXTPROC_HPP)(GLenum op,GLuint res,GLuint arg1);

static inline void ShaderOp1EXT(GLenum op,GLuint res,GLuint arg1)
{
	static PFNSHADEROP1EXTPROC_HPP fn=reinterpret_cast<PFNSHADEROP1EXTPROC_HPP>(_impl::_get_proc_address("glShaderOp1EXT","GL_EXT_vertex_shader"));
	 fn(op,res,arg1);
}

typedef void (*PFNSHADEROP2EXTPROC_HPP)(GLenum op,GLuint res,GLuint arg1,GLuint arg2);

static inline void ShaderOp2EXT(GLenum op,GLuint res,GLuint arg1,GLuint arg2)
{
	static PFNSHADEROP2EXTPROC_HPP fn=reinterpret_cast<PFNSHADEROP2EXTPROC_HPP>(_impl::_get_proc_address("glShaderOp2EXT","GL_EXT_vertex_shader"));
	 fn(op,res,arg1,arg2);
}

typedef void (*PFNSHADEROP3EXTPROC_HPP)(GLenum op,GLuint res,GLuint arg1,GLuint arg2,GLuint arg3);

static inline void ShaderOp3EXT(GLenum op,GLuint res,GLuint arg1,GLuint arg2,GLuint arg3)
{
	static PFNSHADEROP3EXTPROC_HPP fn=reinterpret_cast<PFNSHADEROP3EXTPROC_HPP>(_impl::_get_proc_address("glShaderOp3EXT","GL_EXT_vertex_shader"));
	 fn(op,res,arg1,arg2,arg3);
}

typedef void (*PFNSWIZZLEEXTPROC_HPP)(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW);

static inline void SwizzleEXT(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW)
{
	static PFNSWIZZLEEXTPROC_HPP fn=reinterpret_cast<PFNSWIZZLEEXTPROC_HPP>(_impl::_get_proc_address("glSwizzleEXT","GL_EXT_vertex_shader"));
	 fn(res,in,outX,outY,outZ,outW);
}

typedef void (*PFNWRITEMASKEXTPROC_HPP)(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW);

static inline void WriteMaskEXT(GLuint res,GLuint in,GLenum outX,GLenum outY,GLenum outZ,GLenum outW)
{
	static PFNWRITEMASKEXTPROC_HPP fn=reinterpret_cast<PFNWRITEMASKEXTPROC_HPP>(_impl::_get_proc_address("glWriteMaskEXT","GL_EXT_vertex_shader"));
	 fn(res,in,outX,outY,outZ,outW);
}

typedef void (*PFNINSERTCOMPONENTEXTPROC_HPP)(GLuint res,GLuint src,GLuint num);

static inline void InsertComponentEXT(GLuint res,GLuint src,GLuint num)
{
	static PFNINSERTCOMPONENTEXTPROC_HPP fn=reinterpret_cast<PFNINSERTCOMPONENTEXTPROC_HPP>(_impl::_get_proc_address("glInsertComponentEXT","GL_EXT_vertex_shader"));
	 fn(res,src,num);
}

typedef void (*PFNEXTRACTCOMPONENTEXTPROC_HPP)(GLuint res,GLuint src,GLuint num);

static inline void ExtractComponentEXT(GLuint res,GLuint src,GLuint num)
{
	static PFNEXTRACTCOMPONENTEXTPROC_HPP fn=reinterpret_cast<PFNEXTRACTCOMPONENTEXTPROC_HPP>(_impl::_get_proc_address("glExtractComponentEXT","GL_EXT_vertex_shader"));
	 fn(res,src,num);
}

typedef GLuint (*PFNGENSYMBOLSEXTPROC_HPP)(GLenum datatype,GLenum storagetype,GLenum range,GLuint components);

static inline GLuint GenSymbolsEXT(GLenum datatype,GLenum storagetype,GLenum range,GLuint components)
{
	static PFNGENSYMBOLSEXTPROC_HPP fn=reinterpret_cast<PFNGENSYMBOLSEXTPROC_HPP>(_impl::_get_proc_address("glGenSymbolsEXT","GL_EXT_vertex_shader"));
	return fn(datatype,storagetype,range,components);
}

typedef void (*PFNSETINVARIANTEXTPROC_HPP)(GLuint id,GLenum type,const GLvoid *addr);

static inline void SetInvariantEXT(GLuint id,GLenum type,const GLvoid *addr)
{
	static PFNSETINVARIANTEXTPROC_HPP fn=reinterpret_cast<PFNSETINVARIANTEXTPROC_HPP>(_impl::_get_proc_address("glSetInvariantEXT","GL_EXT_vertex_shader"));
	 fn(id,type,addr);
}

typedef void (*PFNSETLOCALCONSTANTEXTPROC_HPP)(GLuint id,GLenum type,const GLvoid *addr);

static inline void SetLocalConstantEXT(GLuint id,GLenum type,const GLvoid *addr)
{
	static PFNSETLOCALCONSTANTEXTPROC_HPP fn=reinterpret_cast<PFNSETLOCALCONSTANTEXTPROC_HPP>(_impl::_get_proc_address("glSetLocalConstantEXT","GL_EXT_vertex_shader"));
	 fn(id,type,addr);
}

typedef void (*PFNVARIANTBVEXTPROC_HPP)(GLuint id,const GLbyte *addr);

static inline void VariantbvEXT(GLuint id,const GLbyte *addr)
{
	static PFNVARIANTBVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTBVEXTPROC_HPP>(_impl::_get_proc_address("glVariantbvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTSVEXTPROC_HPP)(GLuint id,const GLshort *addr);

static inline void VariantsvEXT(GLuint id,const GLshort *addr)
{
	static PFNVARIANTSVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTSVEXTPROC_HPP>(_impl::_get_proc_address("glVariantsvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTIVEXTPROC_HPP)(GLuint id,const GLint *addr);

static inline void VariantivEXT(GLuint id,const GLint *addr)
{
	static PFNVARIANTIVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTIVEXTPROC_HPP>(_impl::_get_proc_address("glVariantivEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTFVEXTPROC_HPP)(GLuint id,const GLfloat *addr);

static inline void VariantfvEXT(GLuint id,const GLfloat *addr)
{
	static PFNVARIANTFVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTFVEXTPROC_HPP>(_impl::_get_proc_address("glVariantfvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTDVEXTPROC_HPP)(GLuint id,const GLdouble *addr);

static inline void VariantdvEXT(GLuint id,const GLdouble *addr)
{
	static PFNVARIANTDVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTDVEXTPROC_HPP>(_impl::_get_proc_address("glVariantdvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTUBVEXTPROC_HPP)(GLuint id,const GLubyte *addr);

static inline void VariantubvEXT(GLuint id,const GLubyte *addr)
{
	static PFNVARIANTUBVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTUBVEXTPROC_HPP>(_impl::_get_proc_address("glVariantubvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTUSVEXTPROC_HPP)(GLuint id,const GLushort *addr);

static inline void VariantusvEXT(GLuint id,const GLushort *addr)
{
	static PFNVARIANTUSVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTUSVEXTPROC_HPP>(_impl::_get_proc_address("glVariantusvEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTUIVEXTPROC_HPP)(GLuint id,const GLuint *addr);

static inline void VariantuivEXT(GLuint id,const GLuint *addr)
{
	static PFNVARIANTUIVEXTPROC_HPP fn=reinterpret_cast<PFNVARIANTUIVEXTPROC_HPP>(_impl::_get_proc_address("glVariantuivEXT","GL_EXT_vertex_shader"));
	 fn(id,addr);
}

typedef void (*PFNVARIANTPOINTEREXTPROC_HPP)(GLuint id,GLenum type,GLuint stride,const GLvoid *addr);

static inline void VariantPointerEXT(GLuint id,GLenum type,GLuint stride,const GLvoid *addr)
{
	static PFNVARIANTPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNVARIANTPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glVariantPointerEXT","GL_EXT_vertex_shader"));
	 fn(id,type,stride,addr);
}

typedef void (*PFNENABLEVARIANTCLIENTSTATEEXTPROC_HPP)(GLuint id);

static inline void EnableVariantClientStateEXT(GLuint id)
{
	static PFNENABLEVARIANTCLIENTSTATEEXTPROC_HPP fn=reinterpret_cast<PFNENABLEVARIANTCLIENTSTATEEXTPROC_HPP>(_impl::_get_proc_address("glEnableVariantClientStateEXT","GL_EXT_vertex_shader"));
	 fn(id);
}

typedef void (*PFNDISABLEVARIANTCLIENTSTATEEXTPROC_HPP)(GLuint id);

static inline void DisableVariantClientStateEXT(GLuint id)
{
	static PFNDISABLEVARIANTCLIENTSTATEEXTPROC_HPP fn=reinterpret_cast<PFNDISABLEVARIANTCLIENTSTATEEXTPROC_HPP>(_impl::_get_proc_address("glDisableVariantClientStateEXT","GL_EXT_vertex_shader"));
	 fn(id);
}

typedef GLuint (*PFNBINDLIGHTPARAMETEREXTPROC_HPP)(GLenum light,GLenum value);

static inline GLuint BindLightParameterEXT(GLenum light,GLenum value)
{
	static PFNBINDLIGHTPARAMETEREXTPROC_HPP fn=reinterpret_cast<PFNBINDLIGHTPARAMETEREXTPROC_HPP>(_impl::_get_proc_address("glBindLightParameterEXT","GL_EXT_vertex_shader"));
	return fn(light,value);
}

typedef GLuint (*PFNBINDMATERIALPARAMETEREXTPROC_HPP)(GLenum face,GLenum value);

static inline GLuint BindMaterialParameterEXT(GLenum face,GLenum value)
{
	static PFNBINDMATERIALPARAMETEREXTPROC_HPP fn=reinterpret_cast<PFNBINDMATERIALPARAMETEREXTPROC_HPP>(_impl::_get_proc_address("glBindMaterialParameterEXT","GL_EXT_vertex_shader"));
	return fn(face,value);
}

typedef GLuint (*PFNBINDTEXGENPARAMETEREXTPROC_HPP)(GLenum unit,GLenum coord,GLenum value);

static inline GLuint BindTexGenParameterEXT(GLenum unit,GLenum coord,GLenum value)
{
	static PFNBINDTEXGENPARAMETEREXTPROC_HPP fn=reinterpret_cast<PFNBINDTEXGENPARAMETEREXTPROC_HPP>(_impl::_get_proc_address("glBindTexGenParameterEXT","GL_EXT_vertex_shader"));
	return fn(unit,coord,value);
}

typedef GLuint (*PFNBINDTEXTUREUNITPARAMETEREXTPROC_HPP)(GLenum unit,GLenum value);

static inline GLuint BindTextureUnitParameterEXT(GLenum unit,GLenum value)
{
	static PFNBINDTEXTUREUNITPARAMETEREXTPROC_HPP fn=reinterpret_cast<PFNBINDTEXTUREUNITPARAMETEREXTPROC_HPP>(_impl::_get_proc_address("glBindTextureUnitParameterEXT","GL_EXT_vertex_shader"));
	return fn(unit,value);
}

typedef GLuint (*PFNBINDPARAMETEREXTPROC_HPP)(GLenum value);

static inline GLuint BindParameterEXT(GLenum value)
{
	static PFNBINDPARAMETEREXTPROC_HPP fn=reinterpret_cast<PFNBINDPARAMETEREXTPROC_HPP>(_impl::_get_proc_address("glBindParameterEXT","GL_EXT_vertex_shader"));
	return fn(value);
}

typedef GLboolean (*PFNISVARIANTENABLEDEXTPROC_HPP)(GLuint id,GLenum cap);

static inline GLboolean IsVariantEnabledEXT(GLuint id,GLenum cap)
{
	static PFNISVARIANTENABLEDEXTPROC_HPP fn=reinterpret_cast<PFNISVARIANTENABLEDEXTPROC_HPP>(_impl::_get_proc_address("glIsVariantEnabledEXT","GL_EXT_vertex_shader"));
	return fn(id,cap);
}

typedef void (*PFNGETVARIANTBOOLEANVEXTPROC_HPP)(GLuint id,GLenum value,GLboolean *data);

static inline void GetVariantBooleanvEXT(GLuint id,GLenum value,GLboolean *data)
{
	static PFNGETVARIANTBOOLEANVEXTPROC_HPP fn=reinterpret_cast<PFNGETVARIANTBOOLEANVEXTPROC_HPP>(_impl::_get_proc_address("glGetVariantBooleanvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETVARIANTINTEGERVEXTPROC_HPP)(GLuint id,GLenum value,GLint *data);

static inline void GetVariantIntegervEXT(GLuint id,GLenum value,GLint *data)
{
	static PFNGETVARIANTINTEGERVEXTPROC_HPP fn=reinterpret_cast<PFNGETVARIANTINTEGERVEXTPROC_HPP>(_impl::_get_proc_address("glGetVariantIntegervEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETVARIANTFLOATVEXTPROC_HPP)(GLuint id,GLenum value,GLfloat *data);

static inline void GetVariantFloatvEXT(GLuint id,GLenum value,GLfloat *data)
{
	static PFNGETVARIANTFLOATVEXTPROC_HPP fn=reinterpret_cast<PFNGETVARIANTFLOATVEXTPROC_HPP>(_impl::_get_proc_address("glGetVariantFloatvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETVARIANTPOINTERVEXTPROC_HPP)(GLuint id,GLenum value,GLvoid* *data);

static inline void GetVariantPointervEXT(GLuint id,GLenum value,GLvoid* *data)
{
	static PFNGETVARIANTPOINTERVEXTPROC_HPP fn=reinterpret_cast<PFNGETVARIANTPOINTERVEXTPROC_HPP>(_impl::_get_proc_address("glGetVariantPointervEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETINVARIANTBOOLEANVEXTPROC_HPP)(GLuint id,GLenum value,GLboolean *data);

static inline void GetInvariantBooleanvEXT(GLuint id,GLenum value,GLboolean *data)
{
	static PFNGETINVARIANTBOOLEANVEXTPROC_HPP fn=reinterpret_cast<PFNGETINVARIANTBOOLEANVEXTPROC_HPP>(_impl::_get_proc_address("glGetInvariantBooleanvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETINVARIANTINTEGERVEXTPROC_HPP)(GLuint id,GLenum value,GLint *data);

static inline void GetInvariantIntegervEXT(GLuint id,GLenum value,GLint *data)
{
	static PFNGETINVARIANTINTEGERVEXTPROC_HPP fn=reinterpret_cast<PFNGETINVARIANTINTEGERVEXTPROC_HPP>(_impl::_get_proc_address("glGetInvariantIntegervEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETINVARIANTFLOATVEXTPROC_HPP)(GLuint id,GLenum value,GLfloat *data);

static inline void GetInvariantFloatvEXT(GLuint id,GLenum value,GLfloat *data)
{
	static PFNGETINVARIANTFLOATVEXTPROC_HPP fn=reinterpret_cast<PFNGETINVARIANTFLOATVEXTPROC_HPP>(_impl::_get_proc_address("glGetInvariantFloatvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETLOCALCONSTANTBOOLEANVEXTPROC_HPP)(GLuint id,GLenum value,GLboolean *data);

static inline void GetLocalConstantBooleanvEXT(GLuint id,GLenum value,GLboolean *data)
{
	static PFNGETLOCALCONSTANTBOOLEANVEXTPROC_HPP fn=reinterpret_cast<PFNGETLOCALCONSTANTBOOLEANVEXTPROC_HPP>(_impl::_get_proc_address("glGetLocalConstantBooleanvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETLOCALCONSTANTINTEGERVEXTPROC_HPP)(GLuint id,GLenum value,GLint *data);

static inline void GetLocalConstantIntegervEXT(GLuint id,GLenum value,GLint *data)
{
	static PFNGETLOCALCONSTANTINTEGERVEXTPROC_HPP fn=reinterpret_cast<PFNGETLOCALCONSTANTINTEGERVEXTPROC_HPP>(_impl::_get_proc_address("glGetLocalConstantIntegervEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}

typedef void (*PFNGETLOCALCONSTANTFLOATVEXTPROC_HPP)(GLuint id,GLenum value,GLfloat *data);

static inline void GetLocalConstantFloatvEXT(GLuint id,GLenum value,GLfloat *data)
{
	static PFNGETLOCALCONSTANTFLOATVEXTPROC_HPP fn=reinterpret_cast<PFNGETLOCALCONSTANTFLOATVEXTPROC_HPP>(_impl::_get_proc_address("glGetLocalConstantFloatvEXT","GL_EXT_vertex_shader"));
	 fn(id,value,data);
}
#ifndef GL_EXT_vertex_weighting

#define GL_EXT_vertex_weighting
#ifndef GL_MODELVIEW1_STACK_DEPTH_EXT
#define GL_MODELVIEW1_STACK_DEPTH_EXT                                   0x8502
#endif //GL_MODELVIEW1_STACK_DEPTH_EXT
#ifndef GL_MODELVIEW_MATRIX1_EXT
#define GL_MODELVIEW_MATRIX1_EXT                                        0x8506
#endif //GL_MODELVIEW_MATRIX1_EXT
#ifndef GL_VERTEX_WEIGHTING_EXT
#define GL_VERTEX_WEIGHTING_EXT                                         0x8509
#endif //GL_VERTEX_WEIGHTING_EXT
#ifndef GL_MODELVIEW1_EXT
#define GL_MODELVIEW1_EXT                                               0x850A
#endif //GL_MODELVIEW1_EXT
#ifndef GL_CURRENT_VERTEX_WEIGHT_EXT
#define GL_CURRENT_VERTEX_WEIGHT_EXT                                    0x850B
#endif //GL_CURRENT_VERTEX_WEIGHT_EXT
#ifndef GL_VERTEX_WEIGHT_ARRAY_EXT
#define GL_VERTEX_WEIGHT_ARRAY_EXT                                      0x850C
#endif //GL_VERTEX_WEIGHT_ARRAY_EXT
#ifndef GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT
#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT                                 0x850D
#endif //GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT
#ifndef GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT
#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT                                 0x850E
#endif //GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT
#ifndef GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT
#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT                               0x850F
#endif //GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT
#ifndef GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT
#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT                              0x8510
#endif //GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT

#endif //GL_EXT_vertex_weighting


typedef void (*PFNVERTEXWEIGHTFEXTPROC_HPP)(GLfloat weight);

static inline void VertexWeightfEXT(GLfloat weight)
{
	static PFNVERTEXWEIGHTFEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXWEIGHTFEXTPROC_HPP>(_impl::_get_proc_address("glVertexWeightfEXT","GL_EXT_vertex_weighting"));
	 fn(weight);
}

typedef void (*PFNVERTEXWEIGHTFVEXTPROC_HPP)(const GLfloat *weight);

static inline void VertexWeightfvEXT(const GLfloat *weight)
{
	static PFNVERTEXWEIGHTFVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXWEIGHTFVEXTPROC_HPP>(_impl::_get_proc_address("glVertexWeightfvEXT","GL_EXT_vertex_weighting"));
	 fn(weight);
}

typedef void (*PFNVERTEXWEIGHTPOINTEREXTPROC_HPP)(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexWeightPointerEXT(GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXWEIGHTPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXWEIGHTPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glVertexWeightPointerEXT","GL_EXT_vertex_weighting"));
	 fn(size,type,stride,pointer);
}
#ifndef GL_EXT_x11_sync_object

#define GL_EXT_x11_sync_object
#ifndef GL_SYNC_X11_FENCE_EXT
#define GL_SYNC_X11_FENCE_EXT                                           0x90E1
#endif //GL_SYNC_X11_FENCE_EXT

#endif //GL_EXT_x11_sync_object


typedef GLsync (*PFNIMPORTSYNCEXTPROC_HPP)(GLenum external_sync_type,GLintptr external_sync,GLbitfield flags);

static inline GLsync ImportSyncEXT(GLenum external_sync_type,GLintptr external_sync,GLbitfield flags)
{
	static PFNIMPORTSYNCEXTPROC_HPP fn=reinterpret_cast<PFNIMPORTSYNCEXTPROC_HPP>(_impl::_get_proc_address("glImportSyncEXT","GL_EXT_x11_sync_object"));
	return fn(external_sync_type,external_sync,flags);
}
#ifndef GL_EnableCap

#define GL_EnableCap
#ifndef GL_POINT_SMOOTH
#define GL_POINT_SMOOTH                                                 0x0B10
#endif //GL_POINT_SMOOTH
#ifndef GL_LINE_SMOOTH
#define GL_LINE_SMOOTH                                                  0x0B20
#endif //GL_LINE_SMOOTH
#ifndef GL_LINE_STIPPLE
#define GL_LINE_STIPPLE                                                 0x0B24
#endif //GL_LINE_STIPPLE
#ifndef GL_POLYGON_SMOOTH
#define GL_POLYGON_SMOOTH                                               0x0B41
#endif //GL_POLYGON_SMOOTH
#ifndef GL_POLYGON_STIPPLE
#define GL_POLYGON_STIPPLE                                              0x0B42
#endif //GL_POLYGON_STIPPLE
#ifndef GL_CULL_FACE
#define GL_CULL_FACE                                                    0x0B44
#endif //GL_CULL_FACE
#ifndef GL_LIGHTING
#define GL_LIGHTING                                                     0x0B50
#endif //GL_LIGHTING
#ifndef GL_COLOR_MATERIAL
#define GL_COLOR_MATERIAL                                               0x0B57
#endif //GL_COLOR_MATERIAL
#ifndef GL_FOG
#define GL_FOG                                                          0x0B60
#endif //GL_FOG
#ifndef GL_DEPTH_TEST
#define GL_DEPTH_TEST                                                   0x0B71
#endif //GL_DEPTH_TEST
#ifndef GL_STENCIL_TEST
#define GL_STENCIL_TEST                                                 0x0B90
#endif //GL_STENCIL_TEST
#ifndef GL_NORMALIZE
#define GL_NORMALIZE                                                    0x0BA1
#endif //GL_NORMALIZE
#ifndef GL_ALPHA_TEST
#define GL_ALPHA_TEST                                                   0x0BC0
#endif //GL_ALPHA_TEST
#ifndef GL_DITHER
#define GL_DITHER                                                       0x0BD0
#endif //GL_DITHER
#ifndef GL_BLEND
#define GL_BLEND                                                        0x0BE2
#endif //GL_BLEND
#ifndef GL_INDEX_LOGIC_OP
#define GL_INDEX_LOGIC_OP                                               0x0BF1
#endif //GL_INDEX_LOGIC_OP
#ifndef GL_COLOR_LOGIC_OP
#define GL_COLOR_LOGIC_OP                                               0x0BF2
#endif //GL_COLOR_LOGIC_OP
#ifndef GL_SCISSOR_TEST
#define GL_SCISSOR_TEST                                                 0x0C11
#endif //GL_SCISSOR_TEST
#ifndef GL_TEXTURE_GEN_S
#define GL_TEXTURE_GEN_S                                                0x0C60
#endif //GL_TEXTURE_GEN_S
#ifndef GL_TEXTURE_GEN_T
#define GL_TEXTURE_GEN_T                                                0x0C61
#endif //GL_TEXTURE_GEN_T
#ifndef GL_TEXTURE_GEN_R
#define GL_TEXTURE_GEN_R                                                0x0C62
#endif //GL_TEXTURE_GEN_R
#ifndef GL_TEXTURE_GEN_Q
#define GL_TEXTURE_GEN_Q                                                0x0C63
#endif //GL_TEXTURE_GEN_Q
#ifndef GL_AUTO_NORMAL
#define GL_AUTO_NORMAL                                                  0x0D80
#endif //GL_AUTO_NORMAL
#ifndef GL_MAP1_COLOR_4
#define GL_MAP1_COLOR_4                                                 0x0D90
#endif //GL_MAP1_COLOR_4
#ifndef GL_MAP1_INDEX
#define GL_MAP1_INDEX                                                   0x0D91
#endif //GL_MAP1_INDEX
#ifndef GL_MAP1_NORMAL
#define GL_MAP1_NORMAL                                                  0x0D92
#endif //GL_MAP1_NORMAL
#ifndef GL_MAP1_TEXTURE_COORD_1
#define GL_MAP1_TEXTURE_COORD_1                                         0x0D93
#endif //GL_MAP1_TEXTURE_COORD_1
#ifndef GL_MAP1_TEXTURE_COORD_2
#define GL_MAP1_TEXTURE_COORD_2                                         0x0D94
#endif //GL_MAP1_TEXTURE_COORD_2
#ifndef GL_MAP1_TEXTURE_COORD_3
#define GL_MAP1_TEXTURE_COORD_3                                         0x0D95
#endif //GL_MAP1_TEXTURE_COORD_3
#ifndef GL_MAP1_TEXTURE_COORD_4
#define GL_MAP1_TEXTURE_COORD_4                                         0x0D96
#endif //GL_MAP1_TEXTURE_COORD_4
#ifndef GL_MAP1_VERTEX_3
#define GL_MAP1_VERTEX_3                                                0x0D97
#endif //GL_MAP1_VERTEX_3
#ifndef GL_MAP1_VERTEX_4
#define GL_MAP1_VERTEX_4                                                0x0D98
#endif //GL_MAP1_VERTEX_4
#ifndef GL_MAP2_COLOR_4
#define GL_MAP2_COLOR_4                                                 0x0DB0
#endif //GL_MAP2_COLOR_4
#ifndef GL_MAP2_INDEX
#define GL_MAP2_INDEX                                                   0x0DB1
#endif //GL_MAP2_INDEX
#ifndef GL_MAP2_NORMAL
#define GL_MAP2_NORMAL                                                  0x0DB2
#endif //GL_MAP2_NORMAL
#ifndef GL_MAP2_TEXTURE_COORD_1
#define GL_MAP2_TEXTURE_COORD_1                                         0x0DB3
#endif //GL_MAP2_TEXTURE_COORD_1
#ifndef GL_MAP2_TEXTURE_COORD_2
#define GL_MAP2_TEXTURE_COORD_2                                         0x0DB4
#endif //GL_MAP2_TEXTURE_COORD_2
#ifndef GL_MAP2_TEXTURE_COORD_3
#define GL_MAP2_TEXTURE_COORD_3                                         0x0DB5
#endif //GL_MAP2_TEXTURE_COORD_3
#ifndef GL_MAP2_TEXTURE_COORD_4
#define GL_MAP2_TEXTURE_COORD_4                                         0x0DB6
#endif //GL_MAP2_TEXTURE_COORD_4
#ifndef GL_MAP2_VERTEX_3
#define GL_MAP2_VERTEX_3                                                0x0DB7
#endif //GL_MAP2_VERTEX_3
#ifndef GL_MAP2_VERTEX_4
#define GL_MAP2_VERTEX_4                                                0x0DB8
#endif //GL_MAP2_VERTEX_4
#ifndef GL_TEXTURE_1D
#define GL_TEXTURE_1D                                                   0x0DE0
#endif //GL_TEXTURE_1D
#ifndef GL_TEXTURE_2D
#define GL_TEXTURE_2D                                                   0x0DE1
#endif //GL_TEXTURE_2D
#ifndef GL_POLYGON_OFFSET_POINT
#define GL_POLYGON_OFFSET_POINT                                         0x2A01
#endif //GL_POLYGON_OFFSET_POINT
#ifndef GL_POLYGON_OFFSET_LINE
#define GL_POLYGON_OFFSET_LINE                                          0x2A02
#endif //GL_POLYGON_OFFSET_LINE
#ifndef GL_LIGHT0
#define GL_LIGHT0                                                       0x4000
#endif //GL_LIGHT0
#ifndef GL_LIGHT1
#define GL_LIGHT1                                                       0x4001
#endif //GL_LIGHT1
#ifndef GL_LIGHT2
#define GL_LIGHT2                                                       0x4002
#endif //GL_LIGHT2
#ifndef GL_LIGHT3
#define GL_LIGHT3                                                       0x4003
#endif //GL_LIGHT3
#ifndef GL_LIGHT4
#define GL_LIGHT4                                                       0x4004
#endif //GL_LIGHT4
#ifndef GL_LIGHT5
#define GL_LIGHT5                                                       0x4005
#endif //GL_LIGHT5
#ifndef GL_LIGHT6
#define GL_LIGHT6                                                       0x4006
#endif //GL_LIGHT6
#ifndef GL_LIGHT7
#define GL_LIGHT7                                                       0x4007
#endif //GL_LIGHT7
#ifndef GL_POLYGON_OFFSET_FILL
#define GL_POLYGON_OFFSET_FILL                                          0x8037
#endif //GL_POLYGON_OFFSET_FILL
#ifndef GL_VERTEX_ARRAY
#define GL_VERTEX_ARRAY                                                 0x8074
#endif //GL_VERTEX_ARRAY
#ifndef GL_NORMAL_ARRAY
#define GL_NORMAL_ARRAY                                                 0x8075
#endif //GL_NORMAL_ARRAY
#ifndef GL_COLOR_ARRAY
#define GL_COLOR_ARRAY                                                  0x8076
#endif //GL_COLOR_ARRAY
#ifndef GL_INDEX_ARRAY
#define GL_INDEX_ARRAY                                                  0x8077
#endif //GL_INDEX_ARRAY
#ifndef GL_TEXTURE_COORD_ARRAY
#define GL_TEXTURE_COORD_ARRAY                                          0x8078
#endif //GL_TEXTURE_COORD_ARRAY
#ifndef GL_EDGE_FLAG_ARRAY
#define GL_EDGE_FLAG_ARRAY                                              0x8079
#endif //GL_EDGE_FLAG_ARRAY
#ifndef GL_INTERLACE_SGIX
#define GL_INTERLACE_SGIX                                               0x8094
#endif //GL_INTERLACE_SGIX
#ifndef GL_MULTISAMPLE_SGIS
#define GL_MULTISAMPLE_SGIS                                             0x809D
#endif //GL_MULTISAMPLE_SGIS
#ifndef GL_SAMPLE_ALPHA_TO_MASK_SGIS
#define GL_SAMPLE_ALPHA_TO_MASK_SGIS                                    0x809E
#endif //GL_SAMPLE_ALPHA_TO_MASK_SGIS
#ifndef GL_SAMPLE_ALPHA_TO_ONE_SGIS
#define GL_SAMPLE_ALPHA_TO_ONE_SGIS                                     0x809F
#endif //GL_SAMPLE_ALPHA_TO_ONE_SGIS
#ifndef GL_SAMPLE_MASK_SGIS
#define GL_SAMPLE_MASK_SGIS                                             0x80A0
#endif //GL_SAMPLE_MASK_SGIS
#ifndef GL_TEXTURE_4D_SGIS
#define GL_TEXTURE_4D_SGIS                                              0x8134
#endif //GL_TEXTURE_4D_SGIS
#ifndef GL_PIXEL_TEX_GEN_SGIX
#define GL_PIXEL_TEX_GEN_SGIX                                           0x8139
#endif //GL_PIXEL_TEX_GEN_SGIX
#ifndef GL_SPRITE_SGIX
#define GL_SPRITE_SGIX                                                  0x8148
#endif //GL_SPRITE_SGIX
#ifndef GL_REFERENCE_PLANE_SGIX
#define GL_REFERENCE_PLANE_SGIX                                         0x817D
#endif //GL_REFERENCE_PLANE_SGIX
#ifndef GL_IR_INSTRUMENT1_SGIX
#define GL_IR_INSTRUMENT1_SGIX                                          0x817F
#endif //GL_IR_INSTRUMENT1_SGIX
#ifndef GL_CALLIGRAPHIC_FRAGMENT_SGIX
#define GL_CALLIGRAPHIC_FRAGMENT_SGIX                                   0x8183
#endif //GL_CALLIGRAPHIC_FRAGMENT_SGIX
#ifndef GL_FRAMEZOOM_SGIX
#define GL_FRAMEZOOM_SGIX                                               0x818B
#endif //GL_FRAMEZOOM_SGIX
#ifndef GL_FOG_OFFSET_SGIX
#define GL_FOG_OFFSET_SGIX                                              0x8198
#endif //GL_FOG_OFFSET_SGIX
#ifndef GL_ASYNC_HISTOGRAM_SGIX
#define GL_ASYNC_HISTOGRAM_SGIX                                         0x832C
#endif //GL_ASYNC_HISTOGRAM_SGIX
#ifndef GL_PIXEL_TEXTURE_SGIS
#define GL_PIXEL_TEXTURE_SGIS                                           0x8353
#endif //GL_PIXEL_TEXTURE_SGIS
#ifndef GL_ASYNC_TEX_IMAGE_SGIX
#define GL_ASYNC_TEX_IMAGE_SGIX                                         0x835C
#endif //GL_ASYNC_TEX_IMAGE_SGIX
#ifndef GL_ASYNC_DRAW_PIXELS_SGIX
#define GL_ASYNC_DRAW_PIXELS_SGIX                                       0x835D
#endif //GL_ASYNC_DRAW_PIXELS_SGIX
#ifndef GL_ASYNC_READ_PIXELS_SGIX
#define GL_ASYNC_READ_PIXELS_SGIX                                       0x835E
#endif //GL_ASYNC_READ_PIXELS_SGIX
#ifndef GL_FRAGMENT_LIGHTING_SGIX
#define GL_FRAGMENT_LIGHTING_SGIX                                       0x8400
#endif //GL_FRAGMENT_LIGHTING_SGIX
#ifndef GL_FRAGMENT_COLOR_MATERIAL_SGIX
#define GL_FRAGMENT_COLOR_MATERIAL_SGIX                                 0x8401
#endif //GL_FRAGMENT_COLOR_MATERIAL_SGIX
#ifndef GL_FRAGMENT_LIGHT0_SGIX
#define GL_FRAGMENT_LIGHT0_SGIX                                         0x840C
#endif //GL_FRAGMENT_LIGHT0_SGIX
#ifndef GL_FRAGMENT_LIGHT1_SGIX
#define GL_FRAGMENT_LIGHT1_SGIX                                         0x840D
#endif //GL_FRAGMENT_LIGHT1_SGIX
#ifndef GL_FRAGMENT_LIGHT2_SGIX
#define GL_FRAGMENT_LIGHT2_SGIX                                         0x840E
#endif //GL_FRAGMENT_LIGHT2_SGIX
#ifndef GL_FRAGMENT_LIGHT3_SGIX
#define GL_FRAGMENT_LIGHT3_SGIX                                         0x840F
#endif //GL_FRAGMENT_LIGHT3_SGIX
#ifndef GL_FRAGMENT_LIGHT4_SGIX
#define GL_FRAGMENT_LIGHT4_SGIX                                         0x8410
#endif //GL_FRAGMENT_LIGHT4_SGIX
#ifndef GL_FRAGMENT_LIGHT5_SGIX
#define GL_FRAGMENT_LIGHT5_SGIX                                         0x8411
#endif //GL_FRAGMENT_LIGHT5_SGIX
#ifndef GL_FRAGMENT_LIGHT6_SGIX
#define GL_FRAGMENT_LIGHT6_SGIX                                         0x8412
#endif //GL_FRAGMENT_LIGHT6_SGIX
#ifndef GL_FRAGMENT_LIGHT7_SGIX
#define GL_FRAGMENT_LIGHT7_SGIX                                         0x8413
#endif //GL_FRAGMENT_LIGHT7_SGIX

#endif //GL_EnableCap

#ifndef GL_ErrorCode

#define GL_ErrorCode
#ifndef GL_NO_ERROR
#define GL_NO_ERROR                                                     0
#endif //GL_NO_ERROR
#ifndef GL_INVALID_ENUM
#define GL_INVALID_ENUM                                                 0x0500
#endif //GL_INVALID_ENUM
#ifndef GL_INVALID_VALUE
#define GL_INVALID_VALUE                                                0x0501
#endif //GL_INVALID_VALUE
#ifndef GL_INVALID_OPERATION
#define GL_INVALID_OPERATION                                            0x0502
#endif //GL_INVALID_OPERATION
#ifndef GL_STACK_OVERFLOW
#define GL_STACK_OVERFLOW                                               0x0503
#endif //GL_STACK_OVERFLOW
#ifndef GL_STACK_UNDERFLOW
#define GL_STACK_UNDERFLOW                                              0x0504
#endif //GL_STACK_UNDERFLOW
#ifndef GL_OUT_OF_MEMORY
#define GL_OUT_OF_MEMORY                                                0x0505
#endif //GL_OUT_OF_MEMORY

#endif //GL_ErrorCode

#ifndef GL_FJ_shader_binary_GCCSO

#define GL_FJ_shader_binary_GCCSO
#ifndef GL_GCCSO_SHADER_BINARY_FJ
#define GL_GCCSO_SHADER_BINARY_FJ                                       0x9260
#endif //GL_GCCSO_SHADER_BINARY_FJ

#endif //GL_FJ_shader_binary_GCCSO

#ifndef GL_FeedBackToken

#define GL_FeedBackToken
#ifndef GL_PASS_THROUGH_TOKEN
#define GL_PASS_THROUGH_TOKEN                                           0x0700
#endif //GL_PASS_THROUGH_TOKEN
#ifndef GL_POINT_TOKEN
#define GL_POINT_TOKEN                                                  0x0701
#endif //GL_POINT_TOKEN
#ifndef GL_LINE_TOKEN
#define GL_LINE_TOKEN                                                   0x0702
#endif //GL_LINE_TOKEN
#ifndef GL_POLYGON_TOKEN
#define GL_POLYGON_TOKEN                                                0x0703
#endif //GL_POLYGON_TOKEN
#ifndef GL_BITMAP_TOKEN
#define GL_BITMAP_TOKEN                                                 0x0704
#endif //GL_BITMAP_TOKEN
#ifndef GL_DRAW_PIXEL_TOKEN
#define GL_DRAW_PIXEL_TOKEN                                             0x0705
#endif //GL_DRAW_PIXEL_TOKEN
#ifndef GL_COPY_PIXEL_TOKEN
#define GL_COPY_PIXEL_TOKEN                                             0x0706
#endif //GL_COPY_PIXEL_TOKEN
#ifndef GL_LINE_RESET_TOKEN
#define GL_LINE_RESET_TOKEN                                             0x0707
#endif //GL_LINE_RESET_TOKEN

#endif //GL_FeedBackToken

#ifndef GL_FeedbackType

#define GL_FeedbackType
#ifndef GL_2D
#define GL_2D                                                           0x0600
#endif //GL_2D
#ifndef GL_3D
#define GL_3D                                                           0x0601
#endif //GL_3D
#ifndef GL_3D_COLOR
#define GL_3D_COLOR                                                     0x0602
#endif //GL_3D_COLOR
#ifndef GL_3D_COLOR_TEXTURE
#define GL_3D_COLOR_TEXTURE                                             0x0603
#endif //GL_3D_COLOR_TEXTURE
#ifndef GL_4D_COLOR_TEXTURE
#define GL_4D_COLOR_TEXTURE                                             0x0604
#endif //GL_4D_COLOR_TEXTURE

#endif //GL_FeedbackType

#ifndef GL_FfdMaskSGIX

#define GL_FfdMaskSGIX
#ifndef GL_TEXTURE_DEFORMATION_BIT_SGIX
#define GL_TEXTURE_DEFORMATION_BIT_SGIX                                 0x00000001
#endif //GL_TEXTURE_DEFORMATION_BIT_SGIX
#ifndef GL_GEOMETRY_DEFORMATION_BIT_SGIX
#define GL_GEOMETRY_DEFORMATION_BIT_SGIX                                0x00000002
#endif //GL_GEOMETRY_DEFORMATION_BIT_SGIX

#endif //GL_FfdMaskSGIX

#ifndef GL_FfdTargetSGIX

#define GL_FfdTargetSGIX
#ifndef GL_GEOMETRY_DEFORMATION_SGIX
#define GL_GEOMETRY_DEFORMATION_SGIX                                    0x8194
#endif //GL_GEOMETRY_DEFORMATION_SGIX
#ifndef GL_TEXTURE_DEFORMATION_SGIX
#define GL_TEXTURE_DEFORMATION_SGIX                                     0x8195
#endif //GL_TEXTURE_DEFORMATION_SGIX

#endif //GL_FfdTargetSGIX

#ifndef GL_FogMode

#define GL_FogMode
#ifndef GL_EXP
#define GL_EXP                                                          0x0800
#endif //GL_EXP
#ifndef GL_EXP2
#define GL_EXP2                                                         0x0801
#endif //GL_EXP2
#ifndef GL_LINEAR
#define GL_LINEAR                                                       0x2601
#endif //GL_LINEAR
#ifndef GL_FOG_FUNC_SGIS
#define GL_FOG_FUNC_SGIS                                                0x812A
#endif //GL_FOG_FUNC_SGIS

#endif //GL_FogMode

#ifndef GL_FogParameter

#define GL_FogParameter
#ifndef GL_FOG_INDEX
#define GL_FOG_INDEX                                                    0x0B61
#endif //GL_FOG_INDEX
#ifndef GL_FOG_DENSITY
#define GL_FOG_DENSITY                                                  0x0B62
#endif //GL_FOG_DENSITY
#ifndef GL_FOG_START
#define GL_FOG_START                                                    0x0B63
#endif //GL_FOG_START
#ifndef GL_FOG_END
#define GL_FOG_END                                                      0x0B64
#endif //GL_FOG_END
#ifndef GL_FOG_MODE
#define GL_FOG_MODE                                                     0x0B65
#endif //GL_FOG_MODE
#ifndef GL_FOG_COLOR
#define GL_FOG_COLOR                                                    0x0B66
#endif //GL_FOG_COLOR
#ifndef GL_FOG_OFFSET_VALUE_SGIX
#define GL_FOG_OFFSET_VALUE_SGIX                                        0x8199
#endif //GL_FOG_OFFSET_VALUE_SGIX

#endif //GL_FogParameter

#ifndef GL_FragmentLightModelParameterSGIX

#define GL_FragmentLightModelParameterSGIX
#ifndef GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX
#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX                       0x8408
#endif //GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX
#ifndef GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX
#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX                           0x8409
#endif //GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX
#ifndef GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX
#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX                            0x840A
#endif //GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX
#ifndef GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX
#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX               0x840B
#endif //GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX

#endif //GL_FragmentLightModelParameterSGIX

#ifndef GL_FrontFaceDirection

#define GL_FrontFaceDirection
#ifndef GL_CW
#define GL_CW                                                           0x0900
#endif //GL_CW
#ifndef GL_CCW
#define GL_CCW                                                          0x0901
#endif //GL_CCW

#endif //GL_FrontFaceDirection

#ifndef GL_GL_KHR_texture_compression_astc_ldr

#define GL_GL_KHR_texture_compression_astc_ldr
#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR
#define GL_COMPRESSED_RGBA_ASTC_4x4_KHR                                 0x93B0
#endif //GL_COMPRESSED_RGBA_ASTC_4x4_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_5x4_KHR
#define GL_COMPRESSED_RGBA_ASTC_5x4_KHR                                 0x93B1
#endif //GL_COMPRESSED_RGBA_ASTC_5x4_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_5x5_KHR
#define GL_COMPRESSED_RGBA_ASTC_5x5_KHR                                 0x93B2
#endif //GL_COMPRESSED_RGBA_ASTC_5x5_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_6x5_KHR
#define GL_COMPRESSED_RGBA_ASTC_6x5_KHR                                 0x93B3
#endif //GL_COMPRESSED_RGBA_ASTC_6x5_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_6x6_KHR
#define GL_COMPRESSED_RGBA_ASTC_6x6_KHR                                 0x93B4
#endif //GL_COMPRESSED_RGBA_ASTC_6x6_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_8x5_KHR
#define GL_COMPRESSED_RGBA_ASTC_8x5_KHR                                 0x93B5
#endif //GL_COMPRESSED_RGBA_ASTC_8x5_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_8x6_KHR
#define GL_COMPRESSED_RGBA_ASTC_8x6_KHR                                 0x93B6
#endif //GL_COMPRESSED_RGBA_ASTC_8x6_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR
#define GL_COMPRESSED_RGBA_ASTC_8x8_KHR                                 0x93B7
#endif //GL_COMPRESSED_RGBA_ASTC_8x8_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_10x5_KHR
#define GL_COMPRESSED_RGBA_ASTC_10x5_KHR                                0x93B8
#endif //GL_COMPRESSED_RGBA_ASTC_10x5_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_10x6_KHR
#define GL_COMPRESSED_RGBA_ASTC_10x6_KHR                                0x93B9
#endif //GL_COMPRESSED_RGBA_ASTC_10x6_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_10x8_KHR
#define GL_COMPRESSED_RGBA_ASTC_10x8_KHR                                0x93BA
#endif //GL_COMPRESSED_RGBA_ASTC_10x8_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_10x10_KHR
#define GL_COMPRESSED_RGBA_ASTC_10x10_KHR                               0x93BB
#endif //GL_COMPRESSED_RGBA_ASTC_10x10_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_12x10_KHR
#define GL_COMPRESSED_RGBA_ASTC_12x10_KHR                               0x93BC
#endif //GL_COMPRESSED_RGBA_ASTC_12x10_KHR
#ifndef GL_COMPRESSED_RGBA_ASTC_12x12_KHR
#define GL_COMPRESSED_RGBA_ASTC_12x12_KHR                               0x93BD
#endif //GL_COMPRESSED_RGBA_ASTC_12x12_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR                         0x93D0
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR                         0x93D1
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR                         0x93D2
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR                         0x93D3
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR                         0x93D4
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR                         0x93D5
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR                         0x93D6
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR                         0x93D7
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR                        0x93D8
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR                        0x93D9
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR                        0x93DA
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR                       0x93DB
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR                       0x93DC
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR                       0x93DD
#endif //GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR

#endif //GL_GL_KHR_texture_compression_astc_ldr

#ifndef GL_GREMEDY_frame_terminator

#define GL_GREMEDY_frame_terminator

#endif //GL_GREMEDY_frame_terminator


typedef void (*PFNFRAMETERMINATORGREMEDYPROC_HPP)();

static inline void FrameTerminatorGREMEDY()
{
	static PFNFRAMETERMINATORGREMEDYPROC_HPP fn=reinterpret_cast<PFNFRAMETERMINATORGREMEDYPROC_HPP>(_impl::_get_proc_address("glFrameTerminatorGREMEDY","GL_GREMEDY_frame_terminator"));
	 fn();
}
#ifndef GL_GREMEDY_string_marker

#define GL_GREMEDY_string_marker

#endif //GL_GREMEDY_string_marker


typedef void (*PFNSTRINGMARKERGREMEDYPROC_HPP)(GLsizei len,const GLvoid *string);

static inline void StringMarkerGREMEDY(GLsizei len,const GLvoid *string)
{
	static PFNSTRINGMARKERGREMEDYPROC_HPP fn=reinterpret_cast<PFNSTRINGMARKERGREMEDYPROC_HPP>(_impl::_get_proc_address("glStringMarkerGREMEDY","GL_GREMEDY_string_marker"));
	 fn(len,string);
}
#ifndef GL_GetColorTableParameterPNameSGI

#define GL_GetColorTableParameterPNameSGI
#ifndef GL_COLOR_TABLE_FORMAT_SGI
#define GL_COLOR_TABLE_FORMAT_SGI                                       0x80D8
#endif //GL_COLOR_TABLE_FORMAT_SGI
#ifndef GL_COLOR_TABLE_WIDTH_SGI
#define GL_COLOR_TABLE_WIDTH_SGI                                        0x80D9
#endif //GL_COLOR_TABLE_WIDTH_SGI
#ifndef GL_COLOR_TABLE_RED_SIZE_SGI
#define GL_COLOR_TABLE_RED_SIZE_SGI                                     0x80DA
#endif //GL_COLOR_TABLE_RED_SIZE_SGI
#ifndef GL_COLOR_TABLE_GREEN_SIZE_SGI
#define GL_COLOR_TABLE_GREEN_SIZE_SGI                                   0x80DB
#endif //GL_COLOR_TABLE_GREEN_SIZE_SGI
#ifndef GL_COLOR_TABLE_BLUE_SIZE_SGI
#define GL_COLOR_TABLE_BLUE_SIZE_SGI                                    0x80DC
#endif //GL_COLOR_TABLE_BLUE_SIZE_SGI
#ifndef GL_COLOR_TABLE_ALPHA_SIZE_SGI
#define GL_COLOR_TABLE_ALPHA_SIZE_SGI                                   0x80DD
#endif //GL_COLOR_TABLE_ALPHA_SIZE_SGI
#ifndef GL_COLOR_TABLE_LUMINANCE_SIZE_SGI
#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI                               0x80DE
#endif //GL_COLOR_TABLE_LUMINANCE_SIZE_SGI
#ifndef GL_COLOR_TABLE_INTENSITY_SIZE_SGI
#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI                               0x80DF
#endif //GL_COLOR_TABLE_INTENSITY_SIZE_SGI

#endif //GL_GetColorTableParameterPNameSGI

#ifndef GL_GetConvolutionParameter

#define GL_GetConvolutionParameter

#endif //GL_GetConvolutionParameter

#ifndef GL_GetHistogramParameterPNameEXT

#define GL_GetHistogramParameterPNameEXT

#endif //GL_GetHistogramParameterPNameEXT

#ifndef GL_GetMapQuery

#define GL_GetMapQuery
#ifndef GL_COEFF
#define GL_COEFF                                                        0x0A00
#endif //GL_COEFF
#ifndef GL_ORDER
#define GL_ORDER                                                        0x0A01
#endif //GL_ORDER
#ifndef GL_DOMAIN
#define GL_DOMAIN                                                       0x0A02
#endif //GL_DOMAIN

#endif //GL_GetMapQuery

#ifndef GL_GetMinmaxParameterPNameEXT

#define GL_GetMinmaxParameterPNameEXT

#endif //GL_GetMinmaxParameterPNameEXT

#ifndef GL_GetPName

#define GL_GetPName
#ifndef GL_CURRENT_COLOR
#define GL_CURRENT_COLOR                                                0x0B00
#endif //GL_CURRENT_COLOR
#ifndef GL_CURRENT_INDEX
#define GL_CURRENT_INDEX                                                0x0B01
#endif //GL_CURRENT_INDEX
#ifndef GL_CURRENT_NORMAL
#define GL_CURRENT_NORMAL                                               0x0B02
#endif //GL_CURRENT_NORMAL
#ifndef GL_CURRENT_TEXTURE_COORDS
#define GL_CURRENT_TEXTURE_COORDS                                       0x0B03
#endif //GL_CURRENT_TEXTURE_COORDS
#ifndef GL_CURRENT_RASTER_COLOR
#define GL_CURRENT_RASTER_COLOR                                         0x0B04
#endif //GL_CURRENT_RASTER_COLOR
#ifndef GL_CURRENT_RASTER_INDEX
#define GL_CURRENT_RASTER_INDEX                                         0x0B05
#endif //GL_CURRENT_RASTER_INDEX
#ifndef GL_CURRENT_RASTER_TEXTURE_COORDS
#define GL_CURRENT_RASTER_TEXTURE_COORDS                                0x0B06
#endif //GL_CURRENT_RASTER_TEXTURE_COORDS
#ifndef GL_CURRENT_RASTER_POSITION
#define GL_CURRENT_RASTER_POSITION                                      0x0B07
#endif //GL_CURRENT_RASTER_POSITION
#ifndef GL_CURRENT_RASTER_POSITION_VALID
#define GL_CURRENT_RASTER_POSITION_VALID                                0x0B08
#endif //GL_CURRENT_RASTER_POSITION_VALID
#ifndef GL_CURRENT_RASTER_DISTANCE
#define GL_CURRENT_RASTER_DISTANCE                                      0x0B09
#endif //GL_CURRENT_RASTER_DISTANCE
#ifndef GL_POINT_SIZE
#define GL_POINT_SIZE                                                   0x0B11
#endif //GL_POINT_SIZE
#ifndef GL_POINT_SIZE_RANGE
#define GL_POINT_SIZE_RANGE                                             0x0B12
#endif //GL_POINT_SIZE_RANGE
#ifndef GL_POINT_SIZE_GRANULARITY
#define GL_POINT_SIZE_GRANULARITY                                       0x0B13
#endif //GL_POINT_SIZE_GRANULARITY
#ifndef GL_LINE_WIDTH
#define GL_LINE_WIDTH                                                   0x0B21
#endif //GL_LINE_WIDTH
#ifndef GL_LINE_WIDTH_RANGE
#define GL_LINE_WIDTH_RANGE                                             0x0B22
#endif //GL_LINE_WIDTH_RANGE
#ifndef GL_LINE_WIDTH_GRANULARITY
#define GL_LINE_WIDTH_GRANULARITY                                       0x0B23
#endif //GL_LINE_WIDTH_GRANULARITY
#ifndef GL_LINE_STIPPLE_PATTERN
#define GL_LINE_STIPPLE_PATTERN                                         0x0B25
#endif //GL_LINE_STIPPLE_PATTERN
#ifndef GL_LINE_STIPPLE_REPEAT
#define GL_LINE_STIPPLE_REPEAT                                          0x0B26
#endif //GL_LINE_STIPPLE_REPEAT
#ifndef GL_LIST_MODE
#define GL_LIST_MODE                                                    0x0B30
#endif //GL_LIST_MODE
#ifndef GL_MAX_LIST_NESTING
#define GL_MAX_LIST_NESTING                                             0x0B31
#endif //GL_MAX_LIST_NESTING
#ifndef GL_LIST_BASE
#define GL_LIST_BASE                                                    0x0B32
#endif //GL_LIST_BASE
#ifndef GL_LIST_INDEX
#define GL_LIST_INDEX                                                   0x0B33
#endif //GL_LIST_INDEX
#ifndef GL_POLYGON_MODE
#define GL_POLYGON_MODE                                                 0x0B40
#endif //GL_POLYGON_MODE
#ifndef GL_EDGE_FLAG
#define GL_EDGE_FLAG                                                    0x0B43
#endif //GL_EDGE_FLAG
#ifndef GL_CULL_FACE_MODE
#define GL_CULL_FACE_MODE                                               0x0B45
#endif //GL_CULL_FACE_MODE
#ifndef GL_FRONT_FACE
#define GL_FRONT_FACE                                                   0x0B46
#endif //GL_FRONT_FACE
#ifndef GL_LIGHT_MODEL_LOCAL_VIEWER
#define GL_LIGHT_MODEL_LOCAL_VIEWER                                     0x0B51
#endif //GL_LIGHT_MODEL_LOCAL_VIEWER
#ifndef GL_LIGHT_MODEL_TWO_SIDE
#define GL_LIGHT_MODEL_TWO_SIDE                                         0x0B52
#endif //GL_LIGHT_MODEL_TWO_SIDE
#ifndef GL_LIGHT_MODEL_AMBIENT
#define GL_LIGHT_MODEL_AMBIENT                                          0x0B53
#endif //GL_LIGHT_MODEL_AMBIENT
#ifndef GL_SHADE_MODEL
#define GL_SHADE_MODEL                                                  0x0B54
#endif //GL_SHADE_MODEL
#ifndef GL_COLOR_MATERIAL_FACE
#define GL_COLOR_MATERIAL_FACE                                          0x0B55
#endif //GL_COLOR_MATERIAL_FACE
#ifndef GL_COLOR_MATERIAL_PARAMETER
#define GL_COLOR_MATERIAL_PARAMETER                                     0x0B56
#endif //GL_COLOR_MATERIAL_PARAMETER
#ifndef GL_DEPTH_RANGE
#define GL_DEPTH_RANGE                                                  0x0B70
#endif //GL_DEPTH_RANGE
#ifndef GL_DEPTH_WRITEMASK
#define GL_DEPTH_WRITEMASK                                              0x0B72
#endif //GL_DEPTH_WRITEMASK
#ifndef GL_DEPTH_CLEAR_VALUE
#define GL_DEPTH_CLEAR_VALUE                                            0x0B73
#endif //GL_DEPTH_CLEAR_VALUE
#ifndef GL_DEPTH_FUNC
#define GL_DEPTH_FUNC                                                   0x0B74
#endif //GL_DEPTH_FUNC
#ifndef GL_ACCUM_CLEAR_VALUE
#define GL_ACCUM_CLEAR_VALUE                                            0x0B80
#endif //GL_ACCUM_CLEAR_VALUE
#ifndef GL_STENCIL_CLEAR_VALUE
#define GL_STENCIL_CLEAR_VALUE                                          0x0B91
#endif //GL_STENCIL_CLEAR_VALUE
#ifndef GL_STENCIL_FUNC
#define GL_STENCIL_FUNC                                                 0x0B92
#endif //GL_STENCIL_FUNC
#ifndef GL_STENCIL_VALUE_MASK
#define GL_STENCIL_VALUE_MASK                                           0x0B93
#endif //GL_STENCIL_VALUE_MASK
#ifndef GL_STENCIL_FAIL
#define GL_STENCIL_FAIL                                                 0x0B94
#endif //GL_STENCIL_FAIL
#ifndef GL_STENCIL_PASS_DEPTH_FAIL
#define GL_STENCIL_PASS_DEPTH_FAIL                                      0x0B95
#endif //GL_STENCIL_PASS_DEPTH_FAIL
#ifndef GL_STENCIL_PASS_DEPTH_PASS
#define GL_STENCIL_PASS_DEPTH_PASS                                      0x0B96
#endif //GL_STENCIL_PASS_DEPTH_PASS
#ifndef GL_STENCIL_REF
#define GL_STENCIL_REF                                                  0x0B97
#endif //GL_STENCIL_REF
#ifndef GL_STENCIL_WRITEMASK
#define GL_STENCIL_WRITEMASK                                            0x0B98
#endif //GL_STENCIL_WRITEMASK
#ifndef GL_MATRIX_MODE
#define GL_MATRIX_MODE                                                  0x0BA0
#endif //GL_MATRIX_MODE
#ifndef GL_VIEWPORT
#define GL_VIEWPORT                                                     0x0BA2
#endif //GL_VIEWPORT
#ifndef GL_MODELVIEW_STACK_DEPTH
#define GL_MODELVIEW_STACK_DEPTH                                        0x0BA3
#endif //GL_MODELVIEW_STACK_DEPTH
#ifndef GL_PROJECTION_STACK_DEPTH
#define GL_PROJECTION_STACK_DEPTH                                       0x0BA4
#endif //GL_PROJECTION_STACK_DEPTH
#ifndef GL_TEXTURE_STACK_DEPTH
#define GL_TEXTURE_STACK_DEPTH                                          0x0BA5
#endif //GL_TEXTURE_STACK_DEPTH
#ifndef GL_MODELVIEW_MATRIX
#define GL_MODELVIEW_MATRIX                                             0x0BA6
#endif //GL_MODELVIEW_MATRIX
#ifndef GL_PROJECTION_MATRIX
#define GL_PROJECTION_MATRIX                                            0x0BA7
#endif //GL_PROJECTION_MATRIX
#ifndef GL_TEXTURE_MATRIX
#define GL_TEXTURE_MATRIX                                               0x0BA8
#endif //GL_TEXTURE_MATRIX
#ifndef GL_ATTRIB_STACK_DEPTH
#define GL_ATTRIB_STACK_DEPTH                                           0x0BB0
#endif //GL_ATTRIB_STACK_DEPTH
#ifndef GL_CLIENT_ATTRIB_STACK_DEPTH
#define GL_CLIENT_ATTRIB_STACK_DEPTH                                    0x0BB1
#endif //GL_CLIENT_ATTRIB_STACK_DEPTH
#ifndef GL_ALPHA_TEST_FUNC
#define GL_ALPHA_TEST_FUNC                                              0x0BC1
#endif //GL_ALPHA_TEST_FUNC
#ifndef GL_ALPHA_TEST_REF
#define GL_ALPHA_TEST_REF                                               0x0BC2
#endif //GL_ALPHA_TEST_REF
#ifndef GL_BLEND_DST
#define GL_BLEND_DST                                                    0x0BE0
#endif //GL_BLEND_DST
#ifndef GL_BLEND_SRC
#define GL_BLEND_SRC                                                    0x0BE1
#endif //GL_BLEND_SRC
#ifndef GL_LOGIC_OP_MODE
#define GL_LOGIC_OP_MODE                                                0x0BF0
#endif //GL_LOGIC_OP_MODE
#ifndef GL_AUX_BUFFERS
#define GL_AUX_BUFFERS                                                  0x0C00
#endif //GL_AUX_BUFFERS
#ifndef GL_DRAW_BUFFER
#define GL_DRAW_BUFFER                                                  0x0C01
#endif //GL_DRAW_BUFFER
#ifndef GL_READ_BUFFER
#define GL_READ_BUFFER                                                  0x0C02
#endif //GL_READ_BUFFER
#ifndef GL_SCISSOR_BOX
#define GL_SCISSOR_BOX                                                  0x0C10
#endif //GL_SCISSOR_BOX
#ifndef GL_INDEX_CLEAR_VALUE
#define GL_INDEX_CLEAR_VALUE                                            0x0C20
#endif //GL_INDEX_CLEAR_VALUE
#ifndef GL_INDEX_WRITEMASK
#define GL_INDEX_WRITEMASK                                              0x0C21
#endif //GL_INDEX_WRITEMASK
#ifndef GL_COLOR_CLEAR_VALUE
#define GL_COLOR_CLEAR_VALUE                                            0x0C22
#endif //GL_COLOR_CLEAR_VALUE
#ifndef GL_COLOR_WRITEMASK
#define GL_COLOR_WRITEMASK                                              0x0C23
#endif //GL_COLOR_WRITEMASK
#ifndef GL_INDEX_MODE
#define GL_INDEX_MODE                                                   0x0C30
#endif //GL_INDEX_MODE
#ifndef GL_RGBA_MODE
#define GL_RGBA_MODE                                                    0x0C31
#endif //GL_RGBA_MODE
#ifndef GL_DOUBLEBUFFER
#define GL_DOUBLEBUFFER                                                 0x0C32
#endif //GL_DOUBLEBUFFER
#ifndef GL_STEREO
#define GL_STEREO                                                       0x0C33
#endif //GL_STEREO
#ifndef GL_RENDER_MODE
#define GL_RENDER_MODE                                                  0x0C40
#endif //GL_RENDER_MODE
#ifndef GL_PERSPECTIVE_CORRECTION_HINT
#define GL_PERSPECTIVE_CORRECTION_HINT                                  0x0C50
#endif //GL_PERSPECTIVE_CORRECTION_HINT
#ifndef GL_POINT_SMOOTH_HINT
#define GL_POINT_SMOOTH_HINT                                            0x0C51
#endif //GL_POINT_SMOOTH_HINT
#ifndef GL_LINE_SMOOTH_HINT
#define GL_LINE_SMOOTH_HINT                                             0x0C52
#endif //GL_LINE_SMOOTH_HINT
#ifndef GL_POLYGON_SMOOTH_HINT
#define GL_POLYGON_SMOOTH_HINT                                          0x0C53
#endif //GL_POLYGON_SMOOTH_HINT
#ifndef GL_FOG_HINT
#define GL_FOG_HINT                                                     0x0C54
#endif //GL_FOG_HINT
#ifndef GL_PIXEL_MAP_I_TO_I_SIZE
#define GL_PIXEL_MAP_I_TO_I_SIZE                                        0x0CB0
#endif //GL_PIXEL_MAP_I_TO_I_SIZE
#ifndef GL_PIXEL_MAP_S_TO_S_SIZE
#define GL_PIXEL_MAP_S_TO_S_SIZE                                        0x0CB1
#endif //GL_PIXEL_MAP_S_TO_S_SIZE
#ifndef GL_PIXEL_MAP_I_TO_R_SIZE
#define GL_PIXEL_MAP_I_TO_R_SIZE                                        0x0CB2
#endif //GL_PIXEL_MAP_I_TO_R_SIZE
#ifndef GL_PIXEL_MAP_I_TO_G_SIZE
#define GL_PIXEL_MAP_I_TO_G_SIZE                                        0x0CB3
#endif //GL_PIXEL_MAP_I_TO_G_SIZE
#ifndef GL_PIXEL_MAP_I_TO_B_SIZE
#define GL_PIXEL_MAP_I_TO_B_SIZE                                        0x0CB4
#endif //GL_PIXEL_MAP_I_TO_B_SIZE
#ifndef GL_PIXEL_MAP_I_TO_A_SIZE
#define GL_PIXEL_MAP_I_TO_A_SIZE                                        0x0CB5
#endif //GL_PIXEL_MAP_I_TO_A_SIZE
#ifndef GL_PIXEL_MAP_R_TO_R_SIZE
#define GL_PIXEL_MAP_R_TO_R_SIZE                                        0x0CB6
#endif //GL_PIXEL_MAP_R_TO_R_SIZE
#ifndef GL_PIXEL_MAP_G_TO_G_SIZE
#define GL_PIXEL_MAP_G_TO_G_SIZE                                        0x0CB7
#endif //GL_PIXEL_MAP_G_TO_G_SIZE
#ifndef GL_PIXEL_MAP_B_TO_B_SIZE
#define GL_PIXEL_MAP_B_TO_B_SIZE                                        0x0CB8
#endif //GL_PIXEL_MAP_B_TO_B_SIZE
#ifndef GL_PIXEL_MAP_A_TO_A_SIZE
#define GL_PIXEL_MAP_A_TO_A_SIZE                                        0x0CB9
#endif //GL_PIXEL_MAP_A_TO_A_SIZE
#ifndef GL_UNPACK_SWAP_BYTES
#define GL_UNPACK_SWAP_BYTES                                            0x0CF0
#endif //GL_UNPACK_SWAP_BYTES
#ifndef GL_UNPACK_LSB_FIRST
#define GL_UNPACK_LSB_FIRST                                             0x0CF1
#endif //GL_UNPACK_LSB_FIRST
#ifndef GL_UNPACK_ALIGNMENT
#define GL_UNPACK_ALIGNMENT                                             0x0CF5
#endif //GL_UNPACK_ALIGNMENT
#ifndef GL_PACK_SWAP_BYTES
#define GL_PACK_SWAP_BYTES                                              0x0D00
#endif //GL_PACK_SWAP_BYTES
#ifndef GL_PACK_LSB_FIRST
#define GL_PACK_LSB_FIRST                                               0x0D01
#endif //GL_PACK_LSB_FIRST
#ifndef GL_PACK_ROW_LENGTH
#define GL_PACK_ROW_LENGTH                                              0x0D02
#endif //GL_PACK_ROW_LENGTH
#ifndef GL_PACK_SKIP_ROWS
#define GL_PACK_SKIP_ROWS                                               0x0D03
#endif //GL_PACK_SKIP_ROWS
#ifndef GL_PACK_SKIP_PIXELS
#define GL_PACK_SKIP_PIXELS                                             0x0D04
#endif //GL_PACK_SKIP_PIXELS
#ifndef GL_PACK_ALIGNMENT
#define GL_PACK_ALIGNMENT                                               0x0D05
#endif //GL_PACK_ALIGNMENT
#ifndef GL_MAP_COLOR
#define GL_MAP_COLOR                                                    0x0D10
#endif //GL_MAP_COLOR
#ifndef GL_MAP_STENCIL
#define GL_MAP_STENCIL                                                  0x0D11
#endif //GL_MAP_STENCIL
#ifndef GL_INDEX_SHIFT
#define GL_INDEX_SHIFT                                                  0x0D12
#endif //GL_INDEX_SHIFT
#ifndef GL_INDEX_OFFSET
#define GL_INDEX_OFFSET                                                 0x0D13
#endif //GL_INDEX_OFFSET
#ifndef GL_RED_SCALE
#define GL_RED_SCALE                                                    0x0D14
#endif //GL_RED_SCALE
#ifndef GL_RED_BIAS
#define GL_RED_BIAS                                                     0x0D15
#endif //GL_RED_BIAS
#ifndef GL_ZOOM_X
#define GL_ZOOM_X                                                       0x0D16
#endif //GL_ZOOM_X
#ifndef GL_ZOOM_Y
#define GL_ZOOM_Y                                                       0x0D17
#endif //GL_ZOOM_Y
#ifndef GL_GREEN_SCALE
#define GL_GREEN_SCALE                                                  0x0D18
#endif //GL_GREEN_SCALE
#ifndef GL_GREEN_BIAS
#define GL_GREEN_BIAS                                                   0x0D19
#endif //GL_GREEN_BIAS
#ifndef GL_BLUE_SCALE
#define GL_BLUE_SCALE                                                   0x0D1A
#endif //GL_BLUE_SCALE
#ifndef GL_BLUE_BIAS
#define GL_BLUE_BIAS                                                    0x0D1B
#endif //GL_BLUE_BIAS
#ifndef GL_ALPHA_SCALE
#define GL_ALPHA_SCALE                                                  0x0D1C
#endif //GL_ALPHA_SCALE
#ifndef GL_ALPHA_BIAS
#define GL_ALPHA_BIAS                                                   0x0D1D
#endif //GL_ALPHA_BIAS
#ifndef GL_DEPTH_SCALE
#define GL_DEPTH_SCALE                                                  0x0D1E
#endif //GL_DEPTH_SCALE
#ifndef GL_DEPTH_BIAS
#define GL_DEPTH_BIAS                                                   0x0D1F
#endif //GL_DEPTH_BIAS
#ifndef GL_MAX_EVAL_ORDER
#define GL_MAX_EVAL_ORDER                                               0x0D30
#endif //GL_MAX_EVAL_ORDER
#ifndef GL_MAX_LIGHTS
#define GL_MAX_LIGHTS                                                   0x0D31
#endif //GL_MAX_LIGHTS
#ifndef GL_MAX_CLIP_PLANES
#define GL_MAX_CLIP_PLANES                                              0x0D32
#endif //GL_MAX_CLIP_PLANES
#ifndef GL_MAX_CLIP_DISTANCES
#define GL_MAX_CLIP_DISTANCES                                           0x0D32
#endif //GL_MAX_CLIP_DISTANCES
#ifndef GL_MAX_TEXTURE_SIZE
#define GL_MAX_TEXTURE_SIZE                                             0x0D33
#endif //GL_MAX_TEXTURE_SIZE
#ifndef GL_MAX_PIXEL_MAP_TABLE
#define GL_MAX_PIXEL_MAP_TABLE                                          0x0D34
#endif //GL_MAX_PIXEL_MAP_TABLE
#ifndef GL_MAX_ATTRIB_STACK_DEPTH
#define GL_MAX_ATTRIB_STACK_DEPTH                                       0x0D35
#endif //GL_MAX_ATTRIB_STACK_DEPTH
#ifndef GL_MAX_MODELVIEW_STACK_DEPTH
#define GL_MAX_MODELVIEW_STACK_DEPTH                                    0x0D36
#endif //GL_MAX_MODELVIEW_STACK_DEPTH
#ifndef GL_MAX_NAME_STACK_DEPTH
#define GL_MAX_NAME_STACK_DEPTH                                         0x0D37
#endif //GL_MAX_NAME_STACK_DEPTH
#ifndef GL_MAX_PROJECTION_STACK_DEPTH
#define GL_MAX_PROJECTION_STACK_DEPTH                                   0x0D38
#endif //GL_MAX_PROJECTION_STACK_DEPTH
#ifndef GL_MAX_TEXTURE_STACK_DEPTH
#define GL_MAX_TEXTURE_STACK_DEPTH                                      0x0D39
#endif //GL_MAX_TEXTURE_STACK_DEPTH
#ifndef GL_MAX_VIEWPORT_DIMS
#define GL_MAX_VIEWPORT_DIMS                                            0x0D3A
#endif //GL_MAX_VIEWPORT_DIMS
#ifndef GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH                                0x0D3B
#endif //GL_MAX_CLIENT_ATTRIB_STACK_DEPTH
#ifndef GL_SUBPIXEL_BITS
#define GL_SUBPIXEL_BITS                                                0x0D50
#endif //GL_SUBPIXEL_BITS
#ifndef GL_INDEX_BITS
#define GL_INDEX_BITS                                                   0x0D51
#endif //GL_INDEX_BITS
#ifndef GL_RED_BITS
#define GL_RED_BITS                                                     0x0D52
#endif //GL_RED_BITS
#ifndef GL_GREEN_BITS
#define GL_GREEN_BITS                                                   0x0D53
#endif //GL_GREEN_BITS
#ifndef GL_BLUE_BITS
#define GL_BLUE_BITS                                                    0x0D54
#endif //GL_BLUE_BITS
#ifndef GL_ALPHA_BITS
#define GL_ALPHA_BITS                                                   0x0D55
#endif //GL_ALPHA_BITS
#ifndef GL_DEPTH_BITS
#define GL_DEPTH_BITS                                                   0x0D56
#endif //GL_DEPTH_BITS
#ifndef GL_STENCIL_BITS
#define GL_STENCIL_BITS                                                 0x0D57
#endif //GL_STENCIL_BITS
#ifndef GL_ACCUM_RED_BITS
#define GL_ACCUM_RED_BITS                                               0x0D58
#endif //GL_ACCUM_RED_BITS
#ifndef GL_ACCUM_GREEN_BITS
#define GL_ACCUM_GREEN_BITS                                             0x0D59
#endif //GL_ACCUM_GREEN_BITS
#ifndef GL_ACCUM_BLUE_BITS
#define GL_ACCUM_BLUE_BITS                                              0x0D5A
#endif //GL_ACCUM_BLUE_BITS
#ifndef GL_ACCUM_ALPHA_BITS
#define GL_ACCUM_ALPHA_BITS                                             0x0D5B
#endif //GL_ACCUM_ALPHA_BITS
#ifndef GL_NAME_STACK_DEPTH
#define GL_NAME_STACK_DEPTH                                             0x0D70
#endif //GL_NAME_STACK_DEPTH
#ifndef GL_MAP1_GRID_DOMAIN
#define GL_MAP1_GRID_DOMAIN                                             0x0DD0
#endif //GL_MAP1_GRID_DOMAIN
#ifndef GL_MAP1_GRID_SEGMENTS
#define GL_MAP1_GRID_SEGMENTS                                           0x0DD1
#endif //GL_MAP1_GRID_SEGMENTS
#ifndef GL_MAP2_GRID_DOMAIN
#define GL_MAP2_GRID_DOMAIN                                             0x0DD2
#endif //GL_MAP2_GRID_DOMAIN
#ifndef GL_MAP2_GRID_SEGMENTS
#define GL_MAP2_GRID_SEGMENTS                                           0x0DD3
#endif //GL_MAP2_GRID_SEGMENTS
#ifndef GL_FEEDBACK_BUFFER_SIZE
#define GL_FEEDBACK_BUFFER_SIZE                                         0x0DF1
#endif //GL_FEEDBACK_BUFFER_SIZE
#ifndef GL_FEEDBACK_BUFFER_TYPE
#define GL_FEEDBACK_BUFFER_TYPE                                         0x0DF2
#endif //GL_FEEDBACK_BUFFER_TYPE
#ifndef GL_SELECTION_BUFFER_SIZE
#define GL_SELECTION_BUFFER_SIZE                                        0x0DF4
#endif //GL_SELECTION_BUFFER_SIZE
#ifndef GL_POLYGON_OFFSET_UNITS
#define GL_POLYGON_OFFSET_UNITS                                         0x2A00
#endif //GL_POLYGON_OFFSET_UNITS
#ifndef GL_POLYGON_OFFSET_FACTOR
#define GL_POLYGON_OFFSET_FACTOR                                        0x8038
#endif //GL_POLYGON_OFFSET_FACTOR
#ifndef GL_TEXTURE_BINDING_1D
#define GL_TEXTURE_BINDING_1D                                           0x8068
#endif //GL_TEXTURE_BINDING_1D
#ifndef GL_TEXTURE_BINDING_2D
#define GL_TEXTURE_BINDING_2D                                           0x8069
#endif //GL_TEXTURE_BINDING_2D
#ifndef GL_TEXTURE_BINDING_3D
#define GL_TEXTURE_BINDING_3D                                           0x806A
#endif //GL_TEXTURE_BINDING_3D
#ifndef GL_VERTEX_ARRAY_SIZE
#define GL_VERTEX_ARRAY_SIZE                                            0x807A
#endif //GL_VERTEX_ARRAY_SIZE
#ifndef GL_VERTEX_ARRAY_TYPE
#define GL_VERTEX_ARRAY_TYPE                                            0x807B
#endif //GL_VERTEX_ARRAY_TYPE
#ifndef GL_VERTEX_ARRAY_STRIDE
#define GL_VERTEX_ARRAY_STRIDE                                          0x807C
#endif //GL_VERTEX_ARRAY_STRIDE
#ifndef GL_NORMAL_ARRAY_TYPE
#define GL_NORMAL_ARRAY_TYPE                                            0x807E
#endif //GL_NORMAL_ARRAY_TYPE
#ifndef GL_NORMAL_ARRAY_STRIDE
#define GL_NORMAL_ARRAY_STRIDE                                          0x807F
#endif //GL_NORMAL_ARRAY_STRIDE
#ifndef GL_COLOR_ARRAY_SIZE
#define GL_COLOR_ARRAY_SIZE                                             0x8081
#endif //GL_COLOR_ARRAY_SIZE
#ifndef GL_COLOR_ARRAY_TYPE
#define GL_COLOR_ARRAY_TYPE                                             0x8082
#endif //GL_COLOR_ARRAY_TYPE
#ifndef GL_COLOR_ARRAY_STRIDE
#define GL_COLOR_ARRAY_STRIDE                                           0x8083
#endif //GL_COLOR_ARRAY_STRIDE
#ifndef GL_INDEX_ARRAY_TYPE
#define GL_INDEX_ARRAY_TYPE                                             0x8085
#endif //GL_INDEX_ARRAY_TYPE
#ifndef GL_INDEX_ARRAY_STRIDE
#define GL_INDEX_ARRAY_STRIDE                                           0x8086
#endif //GL_INDEX_ARRAY_STRIDE
#ifndef GL_TEXTURE_COORD_ARRAY_SIZE
#define GL_TEXTURE_COORD_ARRAY_SIZE                                     0x8088
#endif //GL_TEXTURE_COORD_ARRAY_SIZE
#ifndef GL_TEXTURE_COORD_ARRAY_TYPE
#define GL_TEXTURE_COORD_ARRAY_TYPE                                     0x8089
#endif //GL_TEXTURE_COORD_ARRAY_TYPE
#ifndef GL_TEXTURE_COORD_ARRAY_STRIDE
#define GL_TEXTURE_COORD_ARRAY_STRIDE                                   0x808A
#endif //GL_TEXTURE_COORD_ARRAY_STRIDE
#ifndef GL_EDGE_FLAG_ARRAY_STRIDE
#define GL_EDGE_FLAG_ARRAY_STRIDE                                       0x808C
#endif //GL_EDGE_FLAG_ARRAY_STRIDE
#ifndef GL_DETAIL_TEXTURE_2D_BINDING_SGIS
#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS                               0x8096
#endif //GL_DETAIL_TEXTURE_2D_BINDING_SGIS
#ifndef GL_SAMPLE_BUFFERS_SGIS
#define GL_SAMPLE_BUFFERS_SGIS                                          0x80A8
#endif //GL_SAMPLE_BUFFERS_SGIS
#ifndef GL_SAMPLES_SGIS
#define GL_SAMPLES_SGIS                                                 0x80A9
#endif //GL_SAMPLES_SGIS
#ifndef GL_SAMPLE_MASK_VALUE_SGIS
#define GL_SAMPLE_MASK_VALUE_SGIS                                       0x80AA
#endif //GL_SAMPLE_MASK_VALUE_SGIS
#ifndef GL_SAMPLE_MASK_INVERT_SGIS
#define GL_SAMPLE_MASK_INVERT_SGIS                                      0x80AB
#endif //GL_SAMPLE_MASK_INVERT_SGIS
#ifndef GL_SAMPLE_PATTERN_SGIS
#define GL_SAMPLE_PATTERN_SGIS                                          0x80AC
#endif //GL_SAMPLE_PATTERN_SGIS
#ifndef GL_COLOR_MATRIX_SGI
#define GL_COLOR_MATRIX_SGI                                             0x80B1
#endif //GL_COLOR_MATRIX_SGI
#ifndef GL_COLOR_MATRIX_STACK_DEPTH_SGI
#define GL_COLOR_MATRIX_STACK_DEPTH_SGI                                 0x80B2
#endif //GL_COLOR_MATRIX_STACK_DEPTH_SGI
#ifndef GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI
#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI                             0x80B3
#endif //GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI
#ifndef GL_POST_COLOR_MATRIX_RED_SCALE_SGI
#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI                              0x80B4
#endif //GL_POST_COLOR_MATRIX_RED_SCALE_SGI
#ifndef GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI
#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI                            0x80B5
#endif //GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI
#ifndef GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI
#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI                             0x80B6
#endif //GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI
#ifndef GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI
#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI                            0x80B7
#endif //GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI
#ifndef GL_POST_COLOR_MATRIX_RED_BIAS_SGI
#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI                               0x80B8
#endif //GL_POST_COLOR_MATRIX_RED_BIAS_SGI
#ifndef GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI
#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI                             0x80B9
#endif //GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI
#ifndef GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI
#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI                              0x80BA
#endif //GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI
#ifndef GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI
#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI                             0x80BB
#endif //GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI
#ifndef GL_POINT_SIZE_MIN_SGIS
#define GL_POINT_SIZE_MIN_SGIS                                          0x8126
#endif //GL_POINT_SIZE_MIN_SGIS
#ifndef GL_POINT_SIZE_MAX_SGIS
#define GL_POINT_SIZE_MAX_SGIS                                          0x8127
#endif //GL_POINT_SIZE_MAX_SGIS
#ifndef GL_POINT_FADE_THRESHOLD_SIZE_SGIS
#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS                               0x8128
#endif //GL_POINT_FADE_THRESHOLD_SIZE_SGIS
#ifndef GL_DISTANCE_ATTENUATION_SGIS
#define GL_DISTANCE_ATTENUATION_SGIS                                    0x8129
#endif //GL_DISTANCE_ATTENUATION_SGIS
#ifndef GL_FOG_FUNC_POINTS_SGIS
#define GL_FOG_FUNC_POINTS_SGIS                                         0x812B
#endif //GL_FOG_FUNC_POINTS_SGIS
#ifndef GL_MAX_FOG_FUNC_POINTS_SGIS
#define GL_MAX_FOG_FUNC_POINTS_SGIS                                     0x812C
#endif //GL_MAX_FOG_FUNC_POINTS_SGIS
#ifndef GL_PACK_SKIP_VOLUMES_SGIS
#define GL_PACK_SKIP_VOLUMES_SGIS                                       0x8130
#endif //GL_PACK_SKIP_VOLUMES_SGIS
#ifndef GL_PACK_IMAGE_DEPTH_SGIS
#define GL_PACK_IMAGE_DEPTH_SGIS                                        0x8131
#endif //GL_PACK_IMAGE_DEPTH_SGIS
#ifndef GL_UNPACK_SKIP_VOLUMES_SGIS
#define GL_UNPACK_SKIP_VOLUMES_SGIS                                     0x8132
#endif //GL_UNPACK_SKIP_VOLUMES_SGIS
#ifndef GL_UNPACK_IMAGE_DEPTH_SGIS
#define GL_UNPACK_IMAGE_DEPTH_SGIS                                      0x8133
#endif //GL_UNPACK_IMAGE_DEPTH_SGIS
#ifndef GL_MAX_4D_TEXTURE_SIZE_SGIS
#define GL_MAX_4D_TEXTURE_SIZE_SGIS                                     0x8138
#endif //GL_MAX_4D_TEXTURE_SIZE_SGIS
#ifndef GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX
#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX                               0x813E
#endif //GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX
#ifndef GL_PIXEL_TILE_CACHE_INCREMENT_SGIX
#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX                              0x813F
#endif //GL_PIXEL_TILE_CACHE_INCREMENT_SGIX
#ifndef GL_PIXEL_TILE_WIDTH_SGIX
#define GL_PIXEL_TILE_WIDTH_SGIX                                        0x8140
#endif //GL_PIXEL_TILE_WIDTH_SGIX
#ifndef GL_PIXEL_TILE_HEIGHT_SGIX
#define GL_PIXEL_TILE_HEIGHT_SGIX                                       0x8141
#endif //GL_PIXEL_TILE_HEIGHT_SGIX
#ifndef GL_PIXEL_TILE_GRID_WIDTH_SGIX
#define GL_PIXEL_TILE_GRID_WIDTH_SGIX                                   0x8142
#endif //GL_PIXEL_TILE_GRID_WIDTH_SGIX
#ifndef GL_PIXEL_TILE_GRID_HEIGHT_SGIX
#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX                                  0x8143
#endif //GL_PIXEL_TILE_GRID_HEIGHT_SGIX
#ifndef GL_PIXEL_TILE_GRID_DEPTH_SGIX
#define GL_PIXEL_TILE_GRID_DEPTH_SGIX                                   0x8144
#endif //GL_PIXEL_TILE_GRID_DEPTH_SGIX
#ifndef GL_PIXEL_TILE_CACHE_SIZE_SGIX
#define GL_PIXEL_TILE_CACHE_SIZE_SGIX                                   0x8145
#endif //GL_PIXEL_TILE_CACHE_SIZE_SGIX
#ifndef GL_SPRITE_MODE_SGIX
#define GL_SPRITE_MODE_SGIX                                             0x8149
#endif //GL_SPRITE_MODE_SGIX
#ifndef GL_SPRITE_AXIS_SGIX
#define GL_SPRITE_AXIS_SGIX                                             0x814A
#endif //GL_SPRITE_AXIS_SGIX
#ifndef GL_SPRITE_TRANSLATION_SGIX
#define GL_SPRITE_TRANSLATION_SGIX                                      0x814B
#endif //GL_SPRITE_TRANSLATION_SGIX
#ifndef GL_TEXTURE_4D_BINDING_SGIS
#define GL_TEXTURE_4D_BINDING_SGIS                                      0x814F
#endif //GL_TEXTURE_4D_BINDING_SGIS
#ifndef GL_MAX_CLIPMAP_DEPTH_SGIX
#define GL_MAX_CLIPMAP_DEPTH_SGIX                                       0x8177
#endif //GL_MAX_CLIPMAP_DEPTH_SGIX
#ifndef GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX
#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX                               0x8178
#endif //GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX
#ifndef GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX
#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX                          0x817B
#endif //GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX
#ifndef GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX
#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX                         0x817C
#endif //GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX
#ifndef GL_REFERENCE_PLANE_EQUATION_SGIX
#define GL_REFERENCE_PLANE_EQUATION_SGIX                                0x817E
#endif //GL_REFERENCE_PLANE_EQUATION_SGIX
#ifndef GL_INSTRUMENT_MEASUREMENTS_SGIX
#define GL_INSTRUMENT_MEASUREMENTS_SGIX                                 0x8181
#endif //GL_INSTRUMENT_MEASUREMENTS_SGIX
#ifndef GL_FRAMEZOOM_FACTOR_SGIX
#define GL_FRAMEZOOM_FACTOR_SGIX                                        0x818C
#endif //GL_FRAMEZOOM_FACTOR_SGIX
#ifndef GL_MAX_FRAMEZOOM_FACTOR_SGIX
#define GL_MAX_FRAMEZOOM_FACTOR_SGIX                                    0x818D
#endif //GL_MAX_FRAMEZOOM_FACTOR_SGIX
#ifndef GL_GENERATE_MIPMAP_HINT_SGIS
#define GL_GENERATE_MIPMAP_HINT_SGIS                                    0x8192
#endif //GL_GENERATE_MIPMAP_HINT_SGIS
#ifndef GL_DEFORMATIONS_MASK_SGIX
#define GL_DEFORMATIONS_MASK_SGIX                                       0x8196
#endif //GL_DEFORMATIONS_MASK_SGIX
#ifndef GL_CONVOLUTION_HINT_SGIX
#define GL_CONVOLUTION_HINT_SGIX                                        0x8316
#endif //GL_CONVOLUTION_HINT_SGIX
#ifndef GL_ASYNC_MARKER_SGIX
#define GL_ASYNC_MARKER_SGIX                                            0x8329
#endif //GL_ASYNC_MARKER_SGIX
#ifndef GL_PIXEL_TEX_GEN_MODE_SGIX
#define GL_PIXEL_TEX_GEN_MODE_SGIX                                      0x832B
#endif //GL_PIXEL_TEX_GEN_MODE_SGIX
#ifndef GL_MAX_ASYNC_HISTOGRAM_SGIX
#define GL_MAX_ASYNC_HISTOGRAM_SGIX                                     0x832D
#endif //GL_MAX_ASYNC_HISTOGRAM_SGIX
#ifndef GL_MAX_ASYNC_TEX_IMAGE_SGIX
#define GL_MAX_ASYNC_TEX_IMAGE_SGIX                                     0x835F
#endif //GL_MAX_ASYNC_TEX_IMAGE_SGIX
#ifndef GL_MAX_ASYNC_DRAW_PIXELS_SGIX
#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX                                   0x8360
#endif //GL_MAX_ASYNC_DRAW_PIXELS_SGIX
#ifndef GL_MAX_ASYNC_READ_PIXELS_SGIX
#define GL_MAX_ASYNC_READ_PIXELS_SGIX                                   0x8361
#endif //GL_MAX_ASYNC_READ_PIXELS_SGIX
#ifndef GL_VERTEX_PRECLIP_SGIX
#define GL_VERTEX_PRECLIP_SGIX                                          0x83EE
#endif //GL_VERTEX_PRECLIP_SGIX
#ifndef GL_VERTEX_PRECLIP_HINT_SGIX
#define GL_VERTEX_PRECLIP_HINT_SGIX                                     0x83EF
#endif //GL_VERTEX_PRECLIP_HINT_SGIX
#ifndef GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX
#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX                            0x8402
#endif //GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX
#ifndef GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX
#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX                       0x8403
#endif //GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX
#ifndef GL_MAX_FRAGMENT_LIGHTS_SGIX
#define GL_MAX_FRAGMENT_LIGHTS_SGIX                                     0x8404
#endif //GL_MAX_FRAGMENT_LIGHTS_SGIX
#ifndef GL_MAX_ACTIVE_LIGHTS_SGIX
#define GL_MAX_ACTIVE_LIGHTS_SGIX                                       0x8405
#endif //GL_MAX_ACTIVE_LIGHTS_SGIX
#ifndef GL_LIGHT_ENV_MODE_SGIX
#define GL_LIGHT_ENV_MODE_SGIX                                          0x8407
#endif //GL_LIGHT_ENV_MODE_SGIX
#ifndef GL_PACK_RESAMPLE_SGIX
#define GL_PACK_RESAMPLE_SGIX                                           0x842E
#endif //GL_PACK_RESAMPLE_SGIX
#ifndef GL_UNPACK_RESAMPLE_SGIX
#define GL_UNPACK_RESAMPLE_SGIX                                         0x842F
#endif //GL_UNPACK_RESAMPLE_SGIX
#ifndef GL_PACK_SUBSAMPLE_RATE_SGIX
#define GL_PACK_SUBSAMPLE_RATE_SGIX                                     0x85A0
#endif //GL_PACK_SUBSAMPLE_RATE_SGIX
#ifndef GL_UNPACK_SUBSAMPLE_RATE_SGIX
#define GL_UNPACK_SUBSAMPLE_RATE_SGIX                                   0x85A1
#endif //GL_UNPACK_SUBSAMPLE_RATE_SGIX

#endif //GL_GetPName

#ifndef GL_GetPixelMap

#define GL_GetPixelMap
#ifndef GL_PIXEL_MAP_I_TO_I
#define GL_PIXEL_MAP_I_TO_I                                             0x0C70
#endif //GL_PIXEL_MAP_I_TO_I
#ifndef GL_PIXEL_MAP_S_TO_S
#define GL_PIXEL_MAP_S_TO_S                                             0x0C71
#endif //GL_PIXEL_MAP_S_TO_S
#ifndef GL_PIXEL_MAP_I_TO_R
#define GL_PIXEL_MAP_I_TO_R                                             0x0C72
#endif //GL_PIXEL_MAP_I_TO_R
#ifndef GL_PIXEL_MAP_I_TO_G
#define GL_PIXEL_MAP_I_TO_G                                             0x0C73
#endif //GL_PIXEL_MAP_I_TO_G
#ifndef GL_PIXEL_MAP_I_TO_B
#define GL_PIXEL_MAP_I_TO_B                                             0x0C74
#endif //GL_PIXEL_MAP_I_TO_B
#ifndef GL_PIXEL_MAP_I_TO_A
#define GL_PIXEL_MAP_I_TO_A                                             0x0C75
#endif //GL_PIXEL_MAP_I_TO_A
#ifndef GL_PIXEL_MAP_R_TO_R
#define GL_PIXEL_MAP_R_TO_R                                             0x0C76
#endif //GL_PIXEL_MAP_R_TO_R
#ifndef GL_PIXEL_MAP_G_TO_G
#define GL_PIXEL_MAP_G_TO_G                                             0x0C77
#endif //GL_PIXEL_MAP_G_TO_G
#ifndef GL_PIXEL_MAP_B_TO_B
#define GL_PIXEL_MAP_B_TO_B                                             0x0C78
#endif //GL_PIXEL_MAP_B_TO_B
#ifndef GL_PIXEL_MAP_A_TO_A
#define GL_PIXEL_MAP_A_TO_A                                             0x0C79
#endif //GL_PIXEL_MAP_A_TO_A

#endif //GL_GetPixelMap

#ifndef GL_GetPointervPName

#define GL_GetPointervPName
#ifndef GL_FEEDBACK_BUFFER_POINTER
#define GL_FEEDBACK_BUFFER_POINTER                                      0x0DF0
#endif //GL_FEEDBACK_BUFFER_POINTER
#ifndef GL_SELECTION_BUFFER_POINTER
#define GL_SELECTION_BUFFER_POINTER                                     0x0DF3
#endif //GL_SELECTION_BUFFER_POINTER
#ifndef GL_VERTEX_ARRAY_POINTER
#define GL_VERTEX_ARRAY_POINTER                                         0x808E
#endif //GL_VERTEX_ARRAY_POINTER
#ifndef GL_NORMAL_ARRAY_POINTER
#define GL_NORMAL_ARRAY_POINTER                                         0x808F
#endif //GL_NORMAL_ARRAY_POINTER
#ifndef GL_COLOR_ARRAY_POINTER
#define GL_COLOR_ARRAY_POINTER                                          0x8090
#endif //GL_COLOR_ARRAY_POINTER
#ifndef GL_INDEX_ARRAY_POINTER
#define GL_INDEX_ARRAY_POINTER                                          0x8091
#endif //GL_INDEX_ARRAY_POINTER
#ifndef GL_TEXTURE_COORD_ARRAY_POINTER
#define GL_TEXTURE_COORD_ARRAY_POINTER                                  0x8092
#endif //GL_TEXTURE_COORD_ARRAY_POINTER
#ifndef GL_EDGE_FLAG_ARRAY_POINTER
#define GL_EDGE_FLAG_ARRAY_POINTER                                      0x8093
#endif //GL_EDGE_FLAG_ARRAY_POINTER
#ifndef GL_INSTRUMENT_BUFFER_POINTER_SGIX
#define GL_INSTRUMENT_BUFFER_POINTER_SGIX                               0x8180
#endif //GL_INSTRUMENT_BUFFER_POINTER_SGIX

#endif //GL_GetPointervPName

#ifndef GL_GetTextureParameter

#define GL_GetTextureParameter
#ifndef GL_TEXTURE_WIDTH
#define GL_TEXTURE_WIDTH                                                0x1000
#endif //GL_TEXTURE_WIDTH
#ifndef GL_TEXTURE_HEIGHT
#define GL_TEXTURE_HEIGHT                                               0x1001
#endif //GL_TEXTURE_HEIGHT
#ifndef GL_TEXTURE_INTERNAL_FORMAT
#define GL_TEXTURE_INTERNAL_FORMAT                                      0x1003
#endif //GL_TEXTURE_INTERNAL_FORMAT
#ifndef GL_TEXTURE_COMPONENTS
#define GL_TEXTURE_COMPONENTS                                           0x1003
#endif //GL_TEXTURE_COMPONENTS
#ifndef GL_TEXTURE_BORDER_COLOR
#define GL_TEXTURE_BORDER_COLOR                                         0x1004
#endif //GL_TEXTURE_BORDER_COLOR
#ifndef GL_TEXTURE_BORDER
#define GL_TEXTURE_BORDER                                               0x1005
#endif //GL_TEXTURE_BORDER
#ifndef GL_TEXTURE_MAG_FILTER
#define GL_TEXTURE_MAG_FILTER                                           0x2800
#endif //GL_TEXTURE_MAG_FILTER
#ifndef GL_TEXTURE_MIN_FILTER
#define GL_TEXTURE_MIN_FILTER                                           0x2801
#endif //GL_TEXTURE_MIN_FILTER
#ifndef GL_TEXTURE_WRAP_S
#define GL_TEXTURE_WRAP_S                                               0x2802
#endif //GL_TEXTURE_WRAP_S
#ifndef GL_TEXTURE_WRAP_T
#define GL_TEXTURE_WRAP_T                                               0x2803
#endif //GL_TEXTURE_WRAP_T
#ifndef GL_TEXTURE_RED_SIZE
#define GL_TEXTURE_RED_SIZE                                             0x805C
#endif //GL_TEXTURE_RED_SIZE
#ifndef GL_TEXTURE_GREEN_SIZE
#define GL_TEXTURE_GREEN_SIZE                                           0x805D
#endif //GL_TEXTURE_GREEN_SIZE
#ifndef GL_TEXTURE_BLUE_SIZE
#define GL_TEXTURE_BLUE_SIZE                                            0x805E
#endif //GL_TEXTURE_BLUE_SIZE
#ifndef GL_TEXTURE_ALPHA_SIZE
#define GL_TEXTURE_ALPHA_SIZE                                           0x805F
#endif //GL_TEXTURE_ALPHA_SIZE
#ifndef GL_TEXTURE_LUMINANCE_SIZE
#define GL_TEXTURE_LUMINANCE_SIZE                                       0x8060
#endif //GL_TEXTURE_LUMINANCE_SIZE
#ifndef GL_TEXTURE_INTENSITY_SIZE
#define GL_TEXTURE_INTENSITY_SIZE                                       0x8061
#endif //GL_TEXTURE_INTENSITY_SIZE
#ifndef GL_TEXTURE_PRIORITY
#define GL_TEXTURE_PRIORITY                                             0x8066
#endif //GL_TEXTURE_PRIORITY
#ifndef GL_TEXTURE_RESIDENT
#define GL_TEXTURE_RESIDENT                                             0x8067
#endif //GL_TEXTURE_RESIDENT
#ifndef GL_DETAIL_TEXTURE_LEVEL_SGIS
#define GL_DETAIL_TEXTURE_LEVEL_SGIS                                    0x809A
#endif //GL_DETAIL_TEXTURE_LEVEL_SGIS
#ifndef GL_DETAIL_TEXTURE_MODE_SGIS
#define GL_DETAIL_TEXTURE_MODE_SGIS                                     0x809B
#endif //GL_DETAIL_TEXTURE_MODE_SGIS
#ifndef GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS
#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS                              0x809C
#endif //GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS
#ifndef GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS
#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS                             0x80B0
#endif //GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS
#ifndef GL_SHADOW_AMBIENT_SGIX
#define GL_SHADOW_AMBIENT_SGIX                                          0x80BF
#endif //GL_SHADOW_AMBIENT_SGIX
#ifndef GL_DUAL_TEXTURE_SELECT_SGIS
#define GL_DUAL_TEXTURE_SELECT_SGIS                                     0x8124
#endif //GL_DUAL_TEXTURE_SELECT_SGIS
#ifndef GL_QUAD_TEXTURE_SELECT_SGIS
#define GL_QUAD_TEXTURE_SELECT_SGIS                                     0x8125
#endif //GL_QUAD_TEXTURE_SELECT_SGIS
#ifndef GL_TEXTURE_4DSIZE_SGIS
#define GL_TEXTURE_4DSIZE_SGIS                                          0x8136
#endif //GL_TEXTURE_4DSIZE_SGIS
#ifndef GL_TEXTURE_WRAP_Q_SGIS
#define GL_TEXTURE_WRAP_Q_SGIS                                          0x8137
#endif //GL_TEXTURE_WRAP_Q_SGIS
#ifndef GL_TEXTURE_MIN_LOD_SGIS
#define GL_TEXTURE_MIN_LOD_SGIS                                         0x813A
#endif //GL_TEXTURE_MIN_LOD_SGIS
#ifndef GL_TEXTURE_MAX_LOD_SGIS
#define GL_TEXTURE_MAX_LOD_SGIS                                         0x813B
#endif //GL_TEXTURE_MAX_LOD_SGIS
#ifndef GL_TEXTURE_BASE_LEVEL_SGIS
#define GL_TEXTURE_BASE_LEVEL_SGIS                                      0x813C
#endif //GL_TEXTURE_BASE_LEVEL_SGIS
#ifndef GL_TEXTURE_MAX_LEVEL_SGIS
#define GL_TEXTURE_MAX_LEVEL_SGIS                                       0x813D
#endif //GL_TEXTURE_MAX_LEVEL_SGIS
#ifndef GL_TEXTURE_FILTER4_SIZE_SGIS
#define GL_TEXTURE_FILTER4_SIZE_SGIS                                    0x8147
#endif //GL_TEXTURE_FILTER4_SIZE_SGIS
#ifndef GL_TEXTURE_CLIPMAP_CENTER_SGIX
#define GL_TEXTURE_CLIPMAP_CENTER_SGIX                                  0x8171
#endif //GL_TEXTURE_CLIPMAP_CENTER_SGIX
#ifndef GL_TEXTURE_CLIPMAP_FRAME_SGIX
#define GL_TEXTURE_CLIPMAP_FRAME_SGIX                                   0x8172
#endif //GL_TEXTURE_CLIPMAP_FRAME_SGIX
#ifndef GL_TEXTURE_CLIPMAP_OFFSET_SGIX
#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX                                  0x8173
#endif //GL_TEXTURE_CLIPMAP_OFFSET_SGIX
#ifndef GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX
#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX                           0x8174
#endif //GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX
#ifndef GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX
#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX                              0x8175
#endif //GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX
#ifndef GL_TEXTURE_CLIPMAP_DEPTH_SGIX
#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX                                   0x8176
#endif //GL_TEXTURE_CLIPMAP_DEPTH_SGIX
#ifndef GL_POST_TEXTURE_FILTER_BIAS_SGIX
#define GL_POST_TEXTURE_FILTER_BIAS_SGIX                                0x8179
#endif //GL_POST_TEXTURE_FILTER_BIAS_SGIX
#ifndef GL_POST_TEXTURE_FILTER_SCALE_SGIX
#define GL_POST_TEXTURE_FILTER_SCALE_SGIX                               0x817A
#endif //GL_POST_TEXTURE_FILTER_SCALE_SGIX
#ifndef GL_TEXTURE_LOD_BIAS_S_SGIX
#define GL_TEXTURE_LOD_BIAS_S_SGIX                                      0x818E
#endif //GL_TEXTURE_LOD_BIAS_S_SGIX
#ifndef GL_TEXTURE_LOD_BIAS_T_SGIX
#define GL_TEXTURE_LOD_BIAS_T_SGIX                                      0x818F
#endif //GL_TEXTURE_LOD_BIAS_T_SGIX
#ifndef GL_TEXTURE_LOD_BIAS_R_SGIX
#define GL_TEXTURE_LOD_BIAS_R_SGIX                                      0x8190
#endif //GL_TEXTURE_LOD_BIAS_R_SGIX
#ifndef GL_GENERATE_MIPMAP_SGIS
#define GL_GENERATE_MIPMAP_SGIS                                         0x8191
#endif //GL_GENERATE_MIPMAP_SGIS
#ifndef GL_TEXTURE_COMPARE_SGIX
#define GL_TEXTURE_COMPARE_SGIX                                         0x819A
#endif //GL_TEXTURE_COMPARE_SGIX
#ifndef GL_TEXTURE_COMPARE_OPERATOR_SGIX
#define GL_TEXTURE_COMPARE_OPERATOR_SGIX                                0x819B
#endif //GL_TEXTURE_COMPARE_OPERATOR_SGIX
#ifndef GL_TEXTURE_LEQUAL_R_SGIX
#define GL_TEXTURE_LEQUAL_R_SGIX                                        0x819C
#endif //GL_TEXTURE_LEQUAL_R_SGIX
#ifndef GL_TEXTURE_GEQUAL_R_SGIX
#define GL_TEXTURE_GEQUAL_R_SGIX                                        0x819D
#endif //GL_TEXTURE_GEQUAL_R_SGIX
#ifndef GL_TEXTURE_MAX_CLAMP_S_SGIX
#define GL_TEXTURE_MAX_CLAMP_S_SGIX                                     0x8369
#endif //GL_TEXTURE_MAX_CLAMP_S_SGIX
#ifndef GL_TEXTURE_MAX_CLAMP_T_SGIX
#define GL_TEXTURE_MAX_CLAMP_T_SGIX                                     0x836A
#endif //GL_TEXTURE_MAX_CLAMP_T_SGIX
#ifndef GL_TEXTURE_MAX_CLAMP_R_SGIX
#define GL_TEXTURE_MAX_CLAMP_R_SGIX                                     0x836B
#endif //GL_TEXTURE_MAX_CLAMP_R_SGIX

#endif //GL_GetTextureParameter

#ifndef GL_HP_convolution_border_modes

#define GL_HP_convolution_border_modes
#ifndef GL_IGNORE_BORDER_HP
#define GL_IGNORE_BORDER_HP                                             0x8150
#endif //GL_IGNORE_BORDER_HP
#ifndef GL_CONSTANT_BORDER_HP
#define GL_CONSTANT_BORDER_HP                                           0x8151
#endif //GL_CONSTANT_BORDER_HP
#ifndef GL_REPLICATE_BORDER_HP
#define GL_REPLICATE_BORDER_HP                                          0x8153
#endif //GL_REPLICATE_BORDER_HP
#ifndef GL_CONVOLUTION_BORDER_COLOR_HP
#define GL_CONVOLUTION_BORDER_COLOR_HP                                  0x8154
#endif //GL_CONVOLUTION_BORDER_COLOR_HP

#endif //GL_HP_convolution_border_modes

#ifndef GL_HP_image_transform

#define GL_HP_image_transform

#endif //GL_HP_image_transform


typedef void (*PFNIMAGETRANSFORMPARAMETERIHPPROC_HPP)(GLenum target,GLenum pname,GLint param);

static inline void ImageTransformParameteriHP(GLenum target,GLenum pname,GLint param)
{
	static PFNIMAGETRANSFORMPARAMETERIHPPROC_HPP fn=reinterpret_cast<PFNIMAGETRANSFORMPARAMETERIHPPROC_HPP>(_impl::_get_proc_address("glImageTransformParameteriHP","GL_HP_image_transform"));
	 fn(target,pname,param);
}

typedef void (*PFNIMAGETRANSFORMPARAMETERFHPPROC_HPP)(GLenum target,GLenum pname,GLfloat param);

static inline void ImageTransformParameterfHP(GLenum target,GLenum pname,GLfloat param)
{
	static PFNIMAGETRANSFORMPARAMETERFHPPROC_HPP fn=reinterpret_cast<PFNIMAGETRANSFORMPARAMETERFHPPROC_HPP>(_impl::_get_proc_address("glImageTransformParameterfHP","GL_HP_image_transform"));
	 fn(target,pname,param);
}

typedef void (*PFNIMAGETRANSFORMPARAMETERIVHPPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void ImageTransformParameterivHP(GLenum target,GLenum pname,const GLint *params)
{
	static PFNIMAGETRANSFORMPARAMETERIVHPPROC_HPP fn=reinterpret_cast<PFNIMAGETRANSFORMPARAMETERIVHPPROC_HPP>(_impl::_get_proc_address("glImageTransformParameterivHP","GL_HP_image_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNIMAGETRANSFORMPARAMETERFVHPPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void ImageTransformParameterfvHP(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNIMAGETRANSFORMPARAMETERFVHPPROC_HPP fn=reinterpret_cast<PFNIMAGETRANSFORMPARAMETERFVHPPROC_HPP>(_impl::_get_proc_address("glImageTransformParameterfvHP","GL_HP_image_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNGETIMAGETRANSFORMPARAMETERIVHPPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetImageTransformParameterivHP(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETIMAGETRANSFORMPARAMETERIVHPPROC_HPP fn=reinterpret_cast<PFNGETIMAGETRANSFORMPARAMETERIVHPPROC_HPP>(_impl::_get_proc_address("glGetImageTransformParameterivHP","GL_HP_image_transform"));
	 fn(target,pname,params);
}

typedef void (*PFNGETIMAGETRANSFORMPARAMETERFVHPPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetImageTransformParameterfvHP(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETIMAGETRANSFORMPARAMETERFVHPPROC_HPP fn=reinterpret_cast<PFNGETIMAGETRANSFORMPARAMETERFVHPPROC_HPP>(_impl::_get_proc_address("glGetImageTransformParameterfvHP","GL_HP_image_transform"));
	 fn(target,pname,params);
}
#ifndef GL_HintMode

#define GL_HintMode
#ifndef GL_DONT_CARE
#define GL_DONT_CARE                                                    0x1100
#endif //GL_DONT_CARE
#ifndef GL_FASTEST
#define GL_FASTEST                                                      0x1101
#endif //GL_FASTEST
#ifndef GL_NICEST
#define GL_NICEST                                                       0x1102
#endif //GL_NICEST

#endif //GL_HintMode

#ifndef GL_HintTarget

#define GL_HintTarget
#ifndef GL_TEXTURE_MULTI_BUFFER_HINT_SGIX
#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX                               0x812E
#endif //GL_TEXTURE_MULTI_BUFFER_HINT_SGIX

#endif //GL_HintTarget

#ifndef GL_HistogramTargetEXT

#define GL_HistogramTargetEXT

#endif //GL_HistogramTargetEXT

#ifndef GL_IBM_multimode_draw_arrays

#define GL_IBM_multimode_draw_arrays

#endif //GL_IBM_multimode_draw_arrays


typedef void (*PFNMULTIMODEDRAWARRAYSIBMPROC_HPP)(const GLenum *mode,const GLint *first,const GLsizei *count,GLsizei primcount,GLint modestride);

static inline void MultiModeDrawArraysIBM(const GLenum *mode,const GLint *first,const GLsizei *count,GLsizei primcount,GLint modestride)
{
	static PFNMULTIMODEDRAWARRAYSIBMPROC_HPP fn=reinterpret_cast<PFNMULTIMODEDRAWARRAYSIBMPROC_HPP>(_impl::_get_proc_address("glMultiModeDrawArraysIBM","GL_IBM_multimode_draw_arrays"));
	 fn(mode,first,count,primcount,modestride);
}

typedef void (*PFNMULTIMODEDRAWELEMENTSIBMPROC_HPP)(const GLenum *mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei primcount,GLint modestride);

static inline void MultiModeDrawElementsIBM(const GLenum *mode,const GLsizei *count,GLenum type,const GLvoid* const *indices,GLsizei primcount,GLint modestride)
{
	static PFNMULTIMODEDRAWELEMENTSIBMPROC_HPP fn=reinterpret_cast<PFNMULTIMODEDRAWELEMENTSIBMPROC_HPP>(_impl::_get_proc_address("glMultiModeDrawElementsIBM","GL_IBM_multimode_draw_arrays"));
	 fn(mode,count,type,indices,primcount,modestride);
}
#ifndef GL_IBM_texture_mirrored_repeat

#define GL_IBM_texture_mirrored_repeat
#ifndef GL_MIRRORED_REPEAT_IBM
#define GL_MIRRORED_REPEAT_IBM                                          0x8370
#endif //GL_MIRRORED_REPEAT_IBM

#endif //GL_IBM_texture_mirrored_repeat

#ifndef GL_IBM_vertex_array_lists

#define GL_IBM_vertex_array_lists

#endif //GL_IBM_vertex_array_lists


typedef void (*PFNCOLORPOINTERLISTIBMPROC_HPP)(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void ColorPointerListIBM(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNCOLORPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNCOLORPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glColorPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(size,type,stride,pointer,ptrstride);
}

typedef void (*PFNSECONDARYCOLORPOINTERLISTIBMPROC_HPP)(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void SecondaryColorPointerListIBM(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNSECONDARYCOLORPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glSecondaryColorPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(size,type,stride,pointer,ptrstride);
}

typedef void (*PFNEDGEFLAGPOINTERLISTIBMPROC_HPP)(GLint stride,const GLboolean* *pointer,GLint ptrstride);

static inline void EdgeFlagPointerListIBM(GLint stride,const GLboolean* *pointer,GLint ptrstride)
{
	static PFNEDGEFLAGPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNEDGEFLAGPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glEdgeFlagPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(stride,pointer,ptrstride);
}

typedef void (*PFNFOGCOORDPOINTERLISTIBMPROC_HPP)(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void FogCoordPointerListIBM(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNFOGCOORDPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNFOGCOORDPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glFogCoordPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(type,stride,pointer,ptrstride);
}

typedef void (*PFNINDEXPOINTERLISTIBMPROC_HPP)(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void IndexPointerListIBM(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNINDEXPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNINDEXPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glIndexPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(type,stride,pointer,ptrstride);
}

typedef void (*PFNNORMALPOINTERLISTIBMPROC_HPP)(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void NormalPointerListIBM(GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNNORMALPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNNORMALPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glNormalPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(type,stride,pointer,ptrstride);
}

typedef void (*PFNTEXCOORDPOINTERLISTIBMPROC_HPP)(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void TexCoordPointerListIBM(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNTEXCOORDPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNTEXCOORDPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glTexCoordPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(size,type,stride,pointer,ptrstride);
}

typedef void (*PFNVERTEXPOINTERLISTIBMPROC_HPP)(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride);

static inline void VertexPointerListIBM(GLint size,GLenum type,GLint stride,const GLvoid* *pointer,GLint ptrstride)
{
	static PFNVERTEXPOINTERLISTIBMPROC_HPP fn=reinterpret_cast<PFNVERTEXPOINTERLISTIBMPROC_HPP>(_impl::_get_proc_address("glVertexPointerListIBM","GL_IBM_vertex_array_lists"));
	 fn(size,type,stride,pointer,ptrstride);
}
#ifndef GL_IMG_multisampled_render_to_texture

#define GL_IMG_multisampled_render_to_texture
#ifndef GL_RENDERBUFFER_SAMPLES_IMG
#define GL_RENDERBUFFER_SAMPLES_IMG                                     0x9133
#endif //GL_RENDERBUFFER_SAMPLES_IMG
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG                       0x9134
#endif //GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG
#ifndef GL_MAX_SAMPLES_IMG
#define GL_MAX_SAMPLES_IMG                                              0x9135
#endif //GL_MAX_SAMPLES_IMG
#ifndef GL_TEXTURE_SAMPLES_IMG
#define GL_TEXTURE_SAMPLES_IMG                                          0x9136
#endif //GL_TEXTURE_SAMPLES_IMG

#endif //GL_IMG_multisampled_render_to_texture

#ifndef GL_IMG_program_binary

#define GL_IMG_program_binary
#ifndef GL_SGX_PROGRAM_BINARY_IMG
#define GL_SGX_PROGRAM_BINARY_IMG                                       0x9130
#endif //GL_SGX_PROGRAM_BINARY_IMG

#endif //GL_IMG_program_binary

#ifndef GL_IMG_shader_binary

#define GL_IMG_shader_binary
#ifndef GL_SGX_BINARY_IMG
#define GL_SGX_BINARY_IMG                                               0x8C0A
#endif //GL_SGX_BINARY_IMG

#endif //GL_IMG_shader_binary

#ifndef GL_IMG_texture_compression_pvrtc

#define GL_IMG_texture_compression_pvrtc
#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG                              0x8C00
#endif //GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
#ifndef GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
#define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG                              0x8C01
#endif //GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG                             0x8C02
#endif //GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
#ifndef GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG                             0x8C03
#endif //GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG

#endif //GL_IMG_texture_compression_pvrtc

#ifndef GL_IMG_texture_env_enhanced_fixed_function

#define GL_IMG_texture_env_enhanced_fixed_function
#ifndef GL_DOT3_RGBA_IMG
#define GL_DOT3_RGBA_IMG                                                0x86AF
#endif //GL_DOT3_RGBA_IMG
#ifndef GL_MODULATE_COLOR_IMG
#define GL_MODULATE_COLOR_IMG                                           0x8C04
#endif //GL_MODULATE_COLOR_IMG
#ifndef GL_RECIP_ADD_SIGNED_ALPHA_IMG
#define GL_RECIP_ADD_SIGNED_ALPHA_IMG                                   0x8C05
#endif //GL_RECIP_ADD_SIGNED_ALPHA_IMG
#ifndef GL_TEXTURE_ALPHA_MODULATE_IMG
#define GL_TEXTURE_ALPHA_MODULATE_IMG                                   0x8C06
#endif //GL_TEXTURE_ALPHA_MODULATE_IMG
#ifndef GL_FACTOR_ALPHA_MODULATE_IMG
#define GL_FACTOR_ALPHA_MODULATE_IMG                                    0x8C07
#endif //GL_FACTOR_ALPHA_MODULATE_IMG
#ifndef GL_FRAGMENT_ALPHA_MODULATE_IMG
#define GL_FRAGMENT_ALPHA_MODULATE_IMG                                  0x8C08
#endif //GL_FRAGMENT_ALPHA_MODULATE_IMG
#ifndef GL_ADD_BLEND_IMG
#define GL_ADD_BLEND_IMG                                                0x8C09
#endif //GL_ADD_BLEND_IMG

#endif //GL_IMG_texture_env_enhanced_fixed_function

#ifndef GL_INGR_blend_func_separate

#define GL_INGR_blend_func_separate

#endif //GL_INGR_blend_func_separate


typedef void (*PFNBLENDFUNCSEPARATEINGRPROC_HPP)(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha);

static inline void BlendFuncSeparateINGR(GLenum sfactorRGB,GLenum dfactorRGB,GLenum sfactorAlpha,GLenum dfactorAlpha)
{
	static PFNBLENDFUNCSEPARATEINGRPROC_HPP fn=reinterpret_cast<PFNBLENDFUNCSEPARATEINGRPROC_HPP>(_impl::_get_proc_address("glBlendFuncSeparateINGR","GL_INGR_blend_func_separate"));
	 fn(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha);
}
#ifndef GL_INGR_color_clamp

#define GL_INGR_color_clamp
#ifndef GL_RED_MIN_CLAMP_INGR
#define GL_RED_MIN_CLAMP_INGR                                           0x8560
#endif //GL_RED_MIN_CLAMP_INGR
#ifndef GL_GREEN_MIN_CLAMP_INGR
#define GL_GREEN_MIN_CLAMP_INGR                                         0x8561
#endif //GL_GREEN_MIN_CLAMP_INGR
#ifndef GL_BLUE_MIN_CLAMP_INGR
#define GL_BLUE_MIN_CLAMP_INGR                                          0x8562
#endif //GL_BLUE_MIN_CLAMP_INGR
#ifndef GL_ALPHA_MIN_CLAMP_INGR
#define GL_ALPHA_MIN_CLAMP_INGR                                         0x8563
#endif //GL_ALPHA_MIN_CLAMP_INGR
#ifndef GL_RED_MAX_CLAMP_INGR
#define GL_RED_MAX_CLAMP_INGR                                           0x8564
#endif //GL_RED_MAX_CLAMP_INGR
#ifndef GL_GREEN_MAX_CLAMP_INGR
#define GL_GREEN_MAX_CLAMP_INGR                                         0x8565
#endif //GL_GREEN_MAX_CLAMP_INGR
#ifndef GL_BLUE_MAX_CLAMP_INGR
#define GL_BLUE_MAX_CLAMP_INGR                                          0x8566
#endif //GL_BLUE_MAX_CLAMP_INGR
#ifndef GL_ALPHA_MAX_CLAMP_INGR
#define GL_ALPHA_MAX_CLAMP_INGR                                         0x8567
#endif //GL_ALPHA_MAX_CLAMP_INGR

#endif //GL_INGR_color_clamp

#ifndef GL_INGR_interlace_read

#define GL_INGR_interlace_read
#ifndef GL_INTERLACE_READ_INGR
#define GL_INTERLACE_READ_INGR                                          0x8568
#endif //GL_INTERLACE_READ_INGR

#endif //GL_INGR_interlace_read

#ifndef GL_INTEL_parallel_arrays

#define GL_INTEL_parallel_arrays
#ifndef GL_PARALLEL_ARRAYS_INTEL
#define GL_PARALLEL_ARRAYS_INTEL                                        0x83F4
#endif //GL_PARALLEL_ARRAYS_INTEL
#ifndef GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL
#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL                         0x83F5
#endif //GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL
#ifndef GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL
#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL                         0x83F6
#endif //GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL
#ifndef GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL
#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL                          0x83F7
#endif //GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL
#ifndef GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL
#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL                  0x83F8
#endif //GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL

#endif //GL_INTEL_parallel_arrays


typedef void (*PFNVERTEXPOINTERVINTELPROC_HPP)(GLint size,GLenum type,const GLvoid* *pointer);

static inline void VertexPointervINTEL(GLint size,GLenum type,const GLvoid* *pointer)
{
	static PFNVERTEXPOINTERVINTELPROC_HPP fn=reinterpret_cast<PFNVERTEXPOINTERVINTELPROC_HPP>(_impl::_get_proc_address("glVertexPointervINTEL","GL_INTEL_parallel_arrays"));
	 fn(size,type,pointer);
}

typedef void (*PFNNORMALPOINTERVINTELPROC_HPP)(GLenum type,const GLvoid* *pointer);

static inline void NormalPointervINTEL(GLenum type,const GLvoid* *pointer)
{
	static PFNNORMALPOINTERVINTELPROC_HPP fn=reinterpret_cast<PFNNORMALPOINTERVINTELPROC_HPP>(_impl::_get_proc_address("glNormalPointervINTEL","GL_INTEL_parallel_arrays"));
	 fn(type,pointer);
}

typedef void (*PFNCOLORPOINTERVINTELPROC_HPP)(GLint size,GLenum type,const GLvoid* *pointer);

static inline void ColorPointervINTEL(GLint size,GLenum type,const GLvoid* *pointer)
{
	static PFNCOLORPOINTERVINTELPROC_HPP fn=reinterpret_cast<PFNCOLORPOINTERVINTELPROC_HPP>(_impl::_get_proc_address("glColorPointervINTEL","GL_INTEL_parallel_arrays"));
	 fn(size,type,pointer);
}

typedef void (*PFNTEXCOORDPOINTERVINTELPROC_HPP)(GLint size,GLenum type,const GLvoid* *pointer);

static inline void TexCoordPointervINTEL(GLint size,GLenum type,const GLvoid* *pointer)
{
	static PFNTEXCOORDPOINTERVINTELPROC_HPP fn=reinterpret_cast<PFNTEXCOORDPOINTERVINTELPROC_HPP>(_impl::_get_proc_address("glTexCoordPointervINTEL","GL_INTEL_parallel_arrays"));
	 fn(size,type,pointer);
}
#ifndef GL_IndexPointerType

#define GL_IndexPointerType

#endif //GL_IndexPointerType

#ifndef GL_InterleavedArrayFormat

#define GL_InterleavedArrayFormat
#ifndef GL_V2F
#define GL_V2F                                                          0x2A20
#endif //GL_V2F
#ifndef GL_V3F
#define GL_V3F                                                          0x2A21
#endif //GL_V3F
#ifndef GL_C4UB_V2F
#define GL_C4UB_V2F                                                     0x2A22
#endif //GL_C4UB_V2F
#ifndef GL_C4UB_V3F
#define GL_C4UB_V3F                                                     0x2A23
#endif //GL_C4UB_V3F
#ifndef GL_C3F_V3F
#define GL_C3F_V3F                                                      0x2A24
#endif //GL_C3F_V3F
#ifndef GL_N3F_V3F
#define GL_N3F_V3F                                                      0x2A25
#endif //GL_N3F_V3F
#ifndef GL_C4F_N3F_V3F
#define GL_C4F_N3F_V3F                                                  0x2A26
#endif //GL_C4F_N3F_V3F
#ifndef GL_T2F_V3F
#define GL_T2F_V3F                                                      0x2A27
#endif //GL_T2F_V3F
#ifndef GL_T4F_V4F
#define GL_T4F_V4F                                                      0x2A28
#endif //GL_T4F_V4F
#ifndef GL_T2F_C4UB_V3F
#define GL_T2F_C4UB_V3F                                                 0x2A29
#endif //GL_T2F_C4UB_V3F
#ifndef GL_T2F_C3F_V3F
#define GL_T2F_C3F_V3F                                                  0x2A2A
#endif //GL_T2F_C3F_V3F
#ifndef GL_T2F_N3F_V3F
#define GL_T2F_N3F_V3F                                                  0x2A2B
#endif //GL_T2F_N3F_V3F
#ifndef GL_T2F_C4F_N3F_V3F
#define GL_T2F_C4F_N3F_V3F                                              0x2A2C
#endif //GL_T2F_C4F_N3F_V3F
#ifndef GL_T4F_C4F_N3F_V4F
#define GL_T4F_C4F_N3F_V4F                                              0x2A2D
#endif //GL_T4F_C4F_N3F_V4F

#endif //GL_InterleavedArrayFormat

#ifndef GL_KHR_debug

#define GL_KHR_debug
#ifndef GL_DEBUG_OUTPUT_SYNCHRONOUS
#define GL_DEBUG_OUTPUT_SYNCHRONOUS                                     0x8242
#endif //GL_DEBUG_OUTPUT_SYNCHRONOUS
#ifndef GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH
#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH                             0x8243
#endif //GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH
#ifndef GL_DEBUG_CALLBACK_FUNCTION
#define GL_DEBUG_CALLBACK_FUNCTION                                      0x8244
#endif //GL_DEBUG_CALLBACK_FUNCTION
#ifndef GL_DEBUG_CALLBACK_USER_PARAM
#define GL_DEBUG_CALLBACK_USER_PARAM                                    0x8245
#endif //GL_DEBUG_CALLBACK_USER_PARAM
#ifndef GL_DEBUG_SOURCE_API
#define GL_DEBUG_SOURCE_API                                             0x8246
#endif //GL_DEBUG_SOURCE_API
#ifndef GL_DEBUG_SOURCE_WINDOW_SYSTEM
#define GL_DEBUG_SOURCE_WINDOW_SYSTEM                                   0x8247
#endif //GL_DEBUG_SOURCE_WINDOW_SYSTEM
#ifndef GL_DEBUG_SOURCE_SHADER_COMPILER
#define GL_DEBUG_SOURCE_SHADER_COMPILER                                 0x8248
#endif //GL_DEBUG_SOURCE_SHADER_COMPILER
#ifndef GL_DEBUG_SOURCE_THIRD_PARTY
#define GL_DEBUG_SOURCE_THIRD_PARTY                                     0x8249
#endif //GL_DEBUG_SOURCE_THIRD_PARTY
#ifndef GL_DEBUG_SOURCE_APPLICATION
#define GL_DEBUG_SOURCE_APPLICATION                                     0x824A
#endif //GL_DEBUG_SOURCE_APPLICATION
#ifndef GL_DEBUG_SOURCE_OTHER
#define GL_DEBUG_SOURCE_OTHER                                           0x824B
#endif //GL_DEBUG_SOURCE_OTHER
#ifndef GL_DEBUG_TYPE_ERROR
#define GL_DEBUG_TYPE_ERROR                                             0x824C
#endif //GL_DEBUG_TYPE_ERROR
#ifndef GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR                               0x824D
#endif //GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR
#ifndef GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR                                0x824E
#endif //GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR
#ifndef GL_DEBUG_TYPE_PORTABILITY
#define GL_DEBUG_TYPE_PORTABILITY                                       0x824F
#endif //GL_DEBUG_TYPE_PORTABILITY
#ifndef GL_DEBUG_TYPE_PERFORMANCE
#define GL_DEBUG_TYPE_PERFORMANCE                                       0x8250
#endif //GL_DEBUG_TYPE_PERFORMANCE
#ifndef GL_DEBUG_TYPE_OTHER
#define GL_DEBUG_TYPE_OTHER                                             0x8251
#endif //GL_DEBUG_TYPE_OTHER
#ifndef GL_DEBUG_TYPE_MARKER
#define GL_DEBUG_TYPE_MARKER                                            0x8268
#endif //GL_DEBUG_TYPE_MARKER
#ifndef GL_DEBUG_TYPE_PUSH_GROUP
#define GL_DEBUG_TYPE_PUSH_GROUP                                        0x8269
#endif //GL_DEBUG_TYPE_PUSH_GROUP
#ifndef GL_DEBUG_TYPE_POP_GROUP
#define GL_DEBUG_TYPE_POP_GROUP                                         0x826A
#endif //GL_DEBUG_TYPE_POP_GROUP
#ifndef GL_DEBUG_SEVERITY_NOTIFICATION
#define GL_DEBUG_SEVERITY_NOTIFICATION                                  0x826B
#endif //GL_DEBUG_SEVERITY_NOTIFICATION
#ifndef GL_MAX_DEBUG_GROUP_STACK_DEPTH
#define GL_MAX_DEBUG_GROUP_STACK_DEPTH                                  0x826C
#endif //GL_MAX_DEBUG_GROUP_STACK_DEPTH
#ifndef GL_DEBUG_GROUP_STACK_DEPTH
#define GL_DEBUG_GROUP_STACK_DEPTH                                      0x826D
#endif //GL_DEBUG_GROUP_STACK_DEPTH
#ifndef GL_BUFFER
#define GL_BUFFER                                                       0x82E0
#endif //GL_BUFFER
#ifndef GL_SHADER
#define GL_SHADER                                                       0x82E1
#endif //GL_SHADER
#ifndef GL_PROGRAM
#define GL_PROGRAM                                                      0x82E2
#endif //GL_PROGRAM
#ifndef GL_QUERY
#define GL_QUERY                                                        0x82E3
#endif //GL_QUERY
#ifndef GL_PROGRAM_PIPELINE
#define GL_PROGRAM_PIPELINE                                             0x82E4
#endif //GL_PROGRAM_PIPELINE
#ifndef GL_SAMPLER
#define GL_SAMPLER                                                      0x82E6
#endif //GL_SAMPLER
#ifndef GL_DISPLAY_LIST
#define GL_DISPLAY_LIST                                                 0x82E7
#endif //GL_DISPLAY_LIST
#ifndef GL_MAX_LABEL_LENGTH
#define GL_MAX_LABEL_LENGTH                                             0x82E8
#endif //GL_MAX_LABEL_LENGTH
#ifndef GL_MAX_DEBUG_MESSAGE_LENGTH
#define GL_MAX_DEBUG_MESSAGE_LENGTH                                     0x9143
#endif //GL_MAX_DEBUG_MESSAGE_LENGTH
#ifndef GL_MAX_DEBUG_LOGGED_MESSAGES
#define GL_MAX_DEBUG_LOGGED_MESSAGES                                    0x9144
#endif //GL_MAX_DEBUG_LOGGED_MESSAGES
#ifndef GL_DEBUG_LOGGED_MESSAGES
#define GL_DEBUG_LOGGED_MESSAGES                                        0x9145
#endif //GL_DEBUG_LOGGED_MESSAGES
#ifndef GL_DEBUG_SEVERITY_HIGH
#define GL_DEBUG_SEVERITY_HIGH                                          0x9146
#endif //GL_DEBUG_SEVERITY_HIGH
#ifndef GL_DEBUG_SEVERITY_MEDIUM
#define GL_DEBUG_SEVERITY_MEDIUM                                        0x9147
#endif //GL_DEBUG_SEVERITY_MEDIUM
#ifndef GL_DEBUG_SEVERITY_LOW
#define GL_DEBUG_SEVERITY_LOW                                           0x9148
#endif //GL_DEBUG_SEVERITY_LOW
#ifndef GL_DEBUG_OUTPUT
#define GL_DEBUG_OUTPUT                                                 0x92E0
#endif //GL_DEBUG_OUTPUT

#endif //GL_KHR_debug


typedef void (*PFNDEBUGMESSAGECONTROLPROC_HPP)(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled);

static inline void DebugMessageControl(GLenum source,GLenum type,GLenum severity,GLsizei count,const GLuint *ids,GLboolean enabled)
{
	static PFNDEBUGMESSAGECONTROLPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGECONTROLPROC_HPP>(_impl::_get_proc_address("glDebugMessageControl","GL_KHR_debug"));
	 fn(source,type,severity,count,ids,enabled);
}

typedef void (*PFNDEBUGMESSAGEINSERTPROC_HPP)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *buf);

static inline void DebugMessageInsert(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *buf)
{
	static PFNDEBUGMESSAGEINSERTPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGEINSERTPROC_HPP>(_impl::_get_proc_address("glDebugMessageInsert","GL_KHR_debug"));
	 fn(source,type,id,severity,length,buf);
}

typedef void (*PFNDEBUGMESSAGECALLBACKPROC_HPP)(GLDEBUGPROC callback,const void *userParam);

static inline void DebugMessageCallback(GLDEBUGPROC callback,const void *userParam)
{
	static PFNDEBUGMESSAGECALLBACKPROC_HPP fn=reinterpret_cast<PFNDEBUGMESSAGECALLBACKPROC_HPP>(_impl::_get_proc_address("glDebugMessageCallback","GL_KHR_debug"));
	 fn(callback,userParam);
}

typedef GLuint (*PFNGETDEBUGMESSAGELOGPROC_HPP)(GLuint count,GLsizei bufsize,GLenum *sources,GLenum *types,GLuint *ids,GLenum *severities,GLsizei *lengths,GLchar *messageLog);

static inline GLuint GetDebugMessageLog(GLuint count,GLsizei bufsize,GLenum *sources,GLenum *types,GLuint *ids,GLenum *severities,GLsizei *lengths,GLchar *messageLog)
{
	static PFNGETDEBUGMESSAGELOGPROC_HPP fn=reinterpret_cast<PFNGETDEBUGMESSAGELOGPROC_HPP>(_impl::_get_proc_address("glGetDebugMessageLog","GL_KHR_debug"));
	return fn(count,bufsize,sources,types,ids,severities,lengths,messageLog);
}

typedef void (*PFNPUSHDEBUGGROUPPROC_HPP)(GLenum source,GLuint id,GLsizei length,const GLchar *message);

static inline void PushDebugGroup(GLenum source,GLuint id,GLsizei length,const GLchar *message)
{
	static PFNPUSHDEBUGGROUPPROC_HPP fn=reinterpret_cast<PFNPUSHDEBUGGROUPPROC_HPP>(_impl::_get_proc_address("glPushDebugGroup","GL_KHR_debug"));
	 fn(source,id,length,message);
}

typedef void (*PFNPOPDEBUGGROUPPROC_HPP)();

static inline void PopDebugGroup()
{
	static PFNPOPDEBUGGROUPPROC_HPP fn=reinterpret_cast<PFNPOPDEBUGGROUPPROC_HPP>(_impl::_get_proc_address("glPopDebugGroup","GL_KHR_debug"));
	 fn();
}

typedef void (*PFNOBJECTLABELPROC_HPP)(GLenum identifier,GLuint name,GLsizei length,const GLchar *label);

static inline void ObjectLabel(GLenum identifier,GLuint name,GLsizei length,const GLchar *label)
{
	static PFNOBJECTLABELPROC_HPP fn=reinterpret_cast<PFNOBJECTLABELPROC_HPP>(_impl::_get_proc_address("glObjectLabel","GL_KHR_debug"));
	 fn(identifier,name,length,label);
}

typedef void (*PFNGETOBJECTLABELPROC_HPP)(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei *length,GLchar *label);

static inline void GetObjectLabel(GLenum identifier,GLuint name,GLsizei bufSize,GLsizei *length,GLchar *label)
{
	static PFNGETOBJECTLABELPROC_HPP fn=reinterpret_cast<PFNGETOBJECTLABELPROC_HPP>(_impl::_get_proc_address("glGetObjectLabel","GL_KHR_debug"));
	 fn(identifier,name,bufSize,length,label);
}

typedef void (*PFNOBJECTPTRLABELPROC_HPP)(const void *ptr,GLsizei length,const GLchar *label);

static inline void ObjectPtrLabel(const void *ptr,GLsizei length,const GLchar *label)
{
	static PFNOBJECTPTRLABELPROC_HPP fn=reinterpret_cast<PFNOBJECTPTRLABELPROC_HPP>(_impl::_get_proc_address("glObjectPtrLabel","GL_KHR_debug"));
	 fn(ptr,length,label);
}

typedef void (*PFNGETOBJECTPTRLABELPROC_HPP)(const void *ptr,GLsizei bufSize,GLsizei *length,GLchar *label);

static inline void GetObjectPtrLabel(const void *ptr,GLsizei bufSize,GLsizei *length,GLchar *label)
{
	static PFNGETOBJECTPTRLABELPROC_HPP fn=reinterpret_cast<PFNGETOBJECTPTRLABELPROC_HPP>(_impl::_get_proc_address("glGetObjectPtrLabel","GL_KHR_debug"));
	 fn(ptr,bufSize,length,label);
}
#ifndef GL_LightEnvModeSGIX

#define GL_LightEnvModeSGIX
#ifndef GL_REPLACE
#define GL_REPLACE                                                      0x1E01
#endif //GL_REPLACE
#ifndef GL_MODULATE
#define GL_MODULATE                                                     0x2100
#endif //GL_MODULATE

#endif //GL_LightEnvModeSGIX

#ifndef GL_LightEnvParameterSGIX

#define GL_LightEnvParameterSGIX

#endif //GL_LightEnvParameterSGIX

#ifndef GL_LightModelColorControl

#define GL_LightModelColorControl

#endif //GL_LightModelColorControl

#ifndef GL_LightModelParameter

#define GL_LightModelParameter

#endif //GL_LightModelParameter

#ifndef GL_LightName

#define GL_LightName

#endif //GL_LightName

#ifndef GL_LightParameter

#define GL_LightParameter
#ifndef GL_POSITION
#define GL_POSITION                                                     0x1203
#endif //GL_POSITION
#ifndef GL_SPOT_DIRECTION
#define GL_SPOT_DIRECTION                                               0x1204
#endif //GL_SPOT_DIRECTION
#ifndef GL_SPOT_EXPONENT
#define GL_SPOT_EXPONENT                                                0x1205
#endif //GL_SPOT_EXPONENT
#ifndef GL_SPOT_CUTOFF
#define GL_SPOT_CUTOFF                                                  0x1206
#endif //GL_SPOT_CUTOFF
#ifndef GL_CONSTANT_ATTENUATION
#define GL_CONSTANT_ATTENUATION                                         0x1207
#endif //GL_CONSTANT_ATTENUATION
#ifndef GL_LINEAR_ATTENUATION
#define GL_LINEAR_ATTENUATION                                           0x1208
#endif //GL_LINEAR_ATTENUATION
#ifndef GL_QUADRATIC_ATTENUATION
#define GL_QUADRATIC_ATTENUATION                                        0x1209
#endif //GL_QUADRATIC_ATTENUATION

#endif //GL_LightParameter

#ifndef GL_ListMode

#define GL_ListMode
#ifndef GL_COMPILE
#define GL_COMPILE                                                      0x1300
#endif //GL_COMPILE
#ifndef GL_COMPILE_AND_EXECUTE
#define GL_COMPILE_AND_EXECUTE                                          0x1301
#endif //GL_COMPILE_AND_EXECUTE

#endif //GL_ListMode

#ifndef GL_ListNameType

#define GL_ListNameType

#endif //GL_ListNameType

#ifndef GL_ListParameterName

#define GL_ListParameterName
#ifndef GL_LIST_PRIORITY_SGIX
#define GL_LIST_PRIORITY_SGIX                                           0x8182
#endif //GL_LIST_PRIORITY_SGIX

#endif //GL_ListParameterName

#ifndef GL_LogicOp

#define GL_LogicOp
#ifndef GL_CLEAR
#define GL_CLEAR                                                        0x1500
#endif //GL_CLEAR
#ifndef GL_AND
#define GL_AND                                                          0x1501
#endif //GL_AND
#ifndef GL_AND_REVERSE
#define GL_AND_REVERSE                                                  0x1502
#endif //GL_AND_REVERSE
#ifndef GL_COPY
#define GL_COPY                                                         0x1503
#endif //GL_COPY
#ifndef GL_AND_INVERTED
#define GL_AND_INVERTED                                                 0x1504
#endif //GL_AND_INVERTED
#ifndef GL_NOOP
#define GL_NOOP                                                         0x1505
#endif //GL_NOOP
#ifndef GL_XOR
#define GL_XOR                                                          0x1506
#endif //GL_XOR
#ifndef GL_OR
#define GL_OR                                                           0x1507
#endif //GL_OR
#ifndef GL_NOR
#define GL_NOR                                                          0x1508
#endif //GL_NOR
#ifndef GL_EQUIV
#define GL_EQUIV                                                        0x1509
#endif //GL_EQUIV
#ifndef GL_INVERT
#define GL_INVERT                                                       0x150A
#endif //GL_INVERT
#ifndef GL_OR_REVERSE
#define GL_OR_REVERSE                                                   0x150B
#endif //GL_OR_REVERSE
#ifndef GL_COPY_INVERTED
#define GL_COPY_INVERTED                                                0x150C
#endif //GL_COPY_INVERTED
#ifndef GL_OR_INVERTED
#define GL_OR_INVERTED                                                  0x150D
#endif //GL_OR_INVERTED
#ifndef GL_NAND
#define GL_NAND                                                         0x150E
#endif //GL_NAND
#ifndef GL_SET
#define GL_SET                                                          0x150F
#endif //GL_SET

#endif //GL_LogicOp

#ifndef GL_MESAX_texture_stack

#define GL_MESAX_texture_stack
#ifndef GL_TEXTURE_1D_STACK_MESAX
#define GL_TEXTURE_1D_STACK_MESAX                                       0x8759
#endif //GL_TEXTURE_1D_STACK_MESAX
#ifndef GL_TEXTURE_2D_STACK_MESAX
#define GL_TEXTURE_2D_STACK_MESAX                                       0x875A
#endif //GL_TEXTURE_2D_STACK_MESAX
#ifndef GL_PROXY_TEXTURE_1D_STACK_MESAX
#define GL_PROXY_TEXTURE_1D_STACK_MESAX                                 0x875B
#endif //GL_PROXY_TEXTURE_1D_STACK_MESAX
#ifndef GL_PROXY_TEXTURE_2D_STACK_MESAX
#define GL_PROXY_TEXTURE_2D_STACK_MESAX                                 0x875C
#endif //GL_PROXY_TEXTURE_2D_STACK_MESAX
#ifndef GL_TEXTURE_1D_STACK_BINDING_MESAX
#define GL_TEXTURE_1D_STACK_BINDING_MESAX                               0x875D
#endif //GL_TEXTURE_1D_STACK_BINDING_MESAX
#ifndef GL_TEXTURE_2D_STACK_BINDING_MESAX
#define GL_TEXTURE_2D_STACK_BINDING_MESAX                               0x875E
#endif //GL_TEXTURE_2D_STACK_BINDING_MESAX

#endif //GL_MESAX_texture_stack

#ifndef GL_MESA_pack_invert

#define GL_MESA_pack_invert
#ifndef GL_PACK_INVERT_MESA
#define GL_PACK_INVERT_MESA                                             0x8758
#endif //GL_PACK_INVERT_MESA

#endif //GL_MESA_pack_invert

#ifndef GL_MESA_packed_depth_stencil

#define GL_MESA_packed_depth_stencil
#ifndef GL_DEPTH_STENCIL_MESA
#define GL_DEPTH_STENCIL_MESA                                           0x8750
#endif //GL_DEPTH_STENCIL_MESA
#ifndef GL_UNSIGNED_INT_24_8_MESA
#define GL_UNSIGNED_INT_24_8_MESA                                       0x8751
#endif //GL_UNSIGNED_INT_24_8_MESA
#ifndef GL_UNSIGNED_INT_8_24_REV_MESA
#define GL_UNSIGNED_INT_8_24_REV_MESA                                   0x8752
#endif //GL_UNSIGNED_INT_8_24_REV_MESA
#ifndef GL_UNSIGNED_SHORT_15_1_MESA
#define GL_UNSIGNED_SHORT_15_1_MESA                                     0x8753
#endif //GL_UNSIGNED_SHORT_15_1_MESA
#ifndef GL_UNSIGNED_SHORT_1_15_REV_MESA
#define GL_UNSIGNED_SHORT_1_15_REV_MESA                                 0x8754
#endif //GL_UNSIGNED_SHORT_1_15_REV_MESA

#endif //GL_MESA_packed_depth_stencil

#ifndef GL_MESA_program_debug

#define GL_MESA_program_debug
#ifndef GL_FRAGMENT_PROGRAM_POSITION_MESA
#define GL_FRAGMENT_PROGRAM_POSITION_MESA                               0x8BB0
#endif //GL_FRAGMENT_PROGRAM_POSITION_MESA
#ifndef GL_FRAGMENT_PROGRAM_CALLBACK_MESA
#define GL_FRAGMENT_PROGRAM_CALLBACK_MESA                               0x8BB1
#endif //GL_FRAGMENT_PROGRAM_CALLBACK_MESA
#ifndef GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA
#define GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA                          0x8BB2
#endif //GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA
#ifndef GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA
#define GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA                          0x8BB3
#endif //GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA
#ifndef GL_VERTEX_PROGRAM_CALLBACK_MESA
#define GL_VERTEX_PROGRAM_CALLBACK_MESA                                 0x8BB4
#endif //GL_VERTEX_PROGRAM_CALLBACK_MESA
#ifndef GL_VERTEX_PROGRAM_POSITION_MESA
#define GL_VERTEX_PROGRAM_POSITION_MESA                                 0x8BB4
#endif //GL_VERTEX_PROGRAM_POSITION_MESA
#ifndef GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA
#define GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA                            0x8BB6
#endif //GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA
#ifndef GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA
#define GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA                            0x8BB7
#endif //GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA

#endif //GL_MESA_program_debug

#ifndef GL_MESA_resize_buffers

#define GL_MESA_resize_buffers

#endif //GL_MESA_resize_buffers


typedef void (*PFNRESIZEBUFFERSMESAPROC_HPP)();

static inline void ResizeBuffersMESA()
{
	static PFNRESIZEBUFFERSMESAPROC_HPP fn=reinterpret_cast<PFNRESIZEBUFFERSMESAPROC_HPP>(_impl::_get_proc_address("glResizeBuffersMESA","GL_MESA_resize_buffers"));
	 fn();
}
#ifndef GL_MESA_shader_debug

#define GL_MESA_shader_debug
#ifndef GL_DEBUG_OBJECT_MESA
#define GL_DEBUG_OBJECT_MESA                                            0x8759
#endif //GL_DEBUG_OBJECT_MESA
#ifndef GL_DEBUG_PRINT_MESA
#define GL_DEBUG_PRINT_MESA                                             0x875A
#endif //GL_DEBUG_PRINT_MESA
#ifndef GL_DEBUG_ASSERT_MESA
#define GL_DEBUG_ASSERT_MESA                                            0x875B
#endif //GL_DEBUG_ASSERT_MESA

#endif //GL_MESA_shader_debug

#ifndef GL_MESA_trace

#define GL_MESA_trace
#ifndef GL_TRACE_OPERATIONS_BIT_MESA
#define GL_TRACE_OPERATIONS_BIT_MESA                                    0x0001
#endif //GL_TRACE_OPERATIONS_BIT_MESA
#ifndef GL_TRACE_PRIMITIVES_BIT_MESA
#define GL_TRACE_PRIMITIVES_BIT_MESA                                    0x0002
#endif //GL_TRACE_PRIMITIVES_BIT_MESA
#ifndef GL_TRACE_ARRAYS_BIT_MESA
#define GL_TRACE_ARRAYS_BIT_MESA                                        0x0004
#endif //GL_TRACE_ARRAYS_BIT_MESA
#ifndef GL_TRACE_TEXTURES_BIT_MESA
#define GL_TRACE_TEXTURES_BIT_MESA                                      0x0008
#endif //GL_TRACE_TEXTURES_BIT_MESA
#ifndef GL_TRACE_PIXELS_BIT_MESA
#define GL_TRACE_PIXELS_BIT_MESA                                        0x0010
#endif //GL_TRACE_PIXELS_BIT_MESA
#ifndef GL_TRACE_ERRORS_BIT_MESA
#define GL_TRACE_ERRORS_BIT_MESA                                        0x0020
#endif //GL_TRACE_ERRORS_BIT_MESA
#ifndef GL_TRACE_MASK_MESA
#define GL_TRACE_MASK_MESA                                              0x8755
#endif //GL_TRACE_MASK_MESA
#ifndef GL_TRACE_NAME_MESA
#define GL_TRACE_NAME_MESA                                              0x8756
#endif //GL_TRACE_NAME_MESA
#ifndef GL_TRACE_ALL_BITS_MESA
#define GL_TRACE_ALL_BITS_MESA                                          0xFFFF
#endif //GL_TRACE_ALL_BITS_MESA

#endif //GL_MESA_trace

#ifndef GL_MESA_window_pos

#define GL_MESA_window_pos

#endif //GL_MESA_window_pos


typedef void (*PFNWINDOWPOS2DMESAPROC_HPP)(GLdouble x,GLdouble y);

static inline void WindowPos2dMESA(GLdouble x,GLdouble y)
{
	static PFNWINDOWPOS2DMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2dMESA","GL_MESA_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2DVMESAPROC_HPP)(const GLdouble *v);

static inline void WindowPos2dvMESA(const GLdouble *v)
{
	static PFNWINDOWPOS2DVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2DVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2dvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2FMESAPROC_HPP)(GLfloat x,GLfloat y);

static inline void WindowPos2fMESA(GLfloat x,GLfloat y)
{
	static PFNWINDOWPOS2FMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2fMESA","GL_MESA_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2FVMESAPROC_HPP)(const GLfloat *v);

static inline void WindowPos2fvMESA(const GLfloat *v)
{
	static PFNWINDOWPOS2FVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2FVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2fvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2IMESAPROC_HPP)(GLint x,GLint y);

static inline void WindowPos2iMESA(GLint x,GLint y)
{
	static PFNWINDOWPOS2IMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2iMESA","GL_MESA_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2IVMESAPROC_HPP)(const GLint *v);

static inline void WindowPos2ivMESA(const GLint *v)
{
	static PFNWINDOWPOS2IVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2IVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2ivMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS2SMESAPROC_HPP)(GLshort x,GLshort y);

static inline void WindowPos2sMESA(GLshort x,GLshort y)
{
	static PFNWINDOWPOS2SMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2sMESA","GL_MESA_window_pos"));
	 fn(x,y);
}

typedef void (*PFNWINDOWPOS2SVMESAPROC_HPP)(const GLshort *v);

static inline void WindowPos2svMESA(const GLshort *v)
{
	static PFNWINDOWPOS2SVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS2SVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos2svMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3DMESAPROC_HPP)(GLdouble x,GLdouble y,GLdouble z);

static inline void WindowPos3dMESA(GLdouble x,GLdouble y,GLdouble z)
{
	static PFNWINDOWPOS3DMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3dMESA","GL_MESA_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3DVMESAPROC_HPP)(const GLdouble *v);

static inline void WindowPos3dvMESA(const GLdouble *v)
{
	static PFNWINDOWPOS3DVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3DVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3dvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3FMESAPROC_HPP)(GLfloat x,GLfloat y,GLfloat z);

static inline void WindowPos3fMESA(GLfloat x,GLfloat y,GLfloat z)
{
	static PFNWINDOWPOS3FMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3fMESA","GL_MESA_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3FVMESAPROC_HPP)(const GLfloat *v);

static inline void WindowPos3fvMESA(const GLfloat *v)
{
	static PFNWINDOWPOS3FVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3FVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3fvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3IMESAPROC_HPP)(GLint x,GLint y,GLint z);

static inline void WindowPos3iMESA(GLint x,GLint y,GLint z)
{
	static PFNWINDOWPOS3IMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3iMESA","GL_MESA_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3IVMESAPROC_HPP)(const GLint *v);

static inline void WindowPos3ivMESA(const GLint *v)
{
	static PFNWINDOWPOS3IVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3IVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3ivMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS3SMESAPROC_HPP)(GLshort x,GLshort y,GLshort z);

static inline void WindowPos3sMESA(GLshort x,GLshort y,GLshort z)
{
	static PFNWINDOWPOS3SMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3sMESA","GL_MESA_window_pos"));
	 fn(x,y,z);
}

typedef void (*PFNWINDOWPOS3SVMESAPROC_HPP)(const GLshort *v);

static inline void WindowPos3svMESA(const GLshort *v)
{
	static PFNWINDOWPOS3SVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS3SVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos3svMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS4DMESAPROC_HPP)(GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void WindowPos4dMESA(GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNWINDOWPOS4DMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4DMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4dMESA","GL_MESA_window_pos"));
	 fn(x,y,z,w);
}

typedef void (*PFNWINDOWPOS4DVMESAPROC_HPP)(const GLdouble *v);

static inline void WindowPos4dvMESA(const GLdouble *v)
{
	static PFNWINDOWPOS4DVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4DVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4dvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS4FMESAPROC_HPP)(GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void WindowPos4fMESA(GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNWINDOWPOS4FMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4FMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4fMESA","GL_MESA_window_pos"));
	 fn(x,y,z,w);
}

typedef void (*PFNWINDOWPOS4FVMESAPROC_HPP)(const GLfloat *v);

static inline void WindowPos4fvMESA(const GLfloat *v)
{
	static PFNWINDOWPOS4FVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4FVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4fvMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS4IMESAPROC_HPP)(GLint x,GLint y,GLint z,GLint w);

static inline void WindowPos4iMESA(GLint x,GLint y,GLint z,GLint w)
{
	static PFNWINDOWPOS4IMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4IMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4iMESA","GL_MESA_window_pos"));
	 fn(x,y,z,w);
}

typedef void (*PFNWINDOWPOS4IVMESAPROC_HPP)(const GLint *v);

static inline void WindowPos4ivMESA(const GLint *v)
{
	static PFNWINDOWPOS4IVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4IVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4ivMESA","GL_MESA_window_pos"));
	 fn(v);
}

typedef void (*PFNWINDOWPOS4SMESAPROC_HPP)(GLshort x,GLshort y,GLshort z,GLshort w);

static inline void WindowPos4sMESA(GLshort x,GLshort y,GLshort z,GLshort w)
{
	static PFNWINDOWPOS4SMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4SMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4sMESA","GL_MESA_window_pos"));
	 fn(x,y,z,w);
}

typedef void (*PFNWINDOWPOS4SVMESAPROC_HPP)(const GLshort *v);

static inline void WindowPos4svMESA(const GLshort *v)
{
	static PFNWINDOWPOS4SVMESAPROC_HPP fn=reinterpret_cast<PFNWINDOWPOS4SVMESAPROC_HPP>(_impl::_get_proc_address("glWindowPos4svMESA","GL_MESA_window_pos"));
	 fn(v);
}
#ifndef GL_MESA_ycbcr_texture

#define GL_MESA_ycbcr_texture
#ifndef GL_UNSIGNED_SHORT_8_8_MESA
#define GL_UNSIGNED_SHORT_8_8_MESA                                      0x85BA
#endif //GL_UNSIGNED_SHORT_8_8_MESA
#ifndef GL_UNSIGNED_SHORT_8_8_REV_MESA
#define GL_UNSIGNED_SHORT_8_8_REV_MESA                                  0x85BB
#endif //GL_UNSIGNED_SHORT_8_8_REV_MESA
#ifndef GL_YCBCR_MESA
#define GL_YCBCR_MESA                                                   0x8757
#endif //GL_YCBCR_MESA

#endif //GL_MESA_ycbcr_texture

#ifndef GL_MapTarget

#define GL_MapTarget

#endif //GL_MapTarget

#ifndef GL_MaterialFace

#define GL_MaterialFace

#endif //GL_MaterialFace

#ifndef GL_MaterialParameter

#define GL_MaterialParameter
#ifndef GL_SHININESS
#define GL_SHININESS                                                    0x1601
#endif //GL_SHININESS
#ifndef GL_COLOR_INDEXES
#define GL_COLOR_INDEXES                                                0x1603
#endif //GL_COLOR_INDEXES

#endif //GL_MaterialParameter

#ifndef GL_MatrixMode

#define GL_MatrixMode
#ifndef GL_MODELVIEW
#define GL_MODELVIEW                                                    0x1700
#endif //GL_MODELVIEW
#ifndef GL_PROJECTION
#define GL_PROJECTION                                                   0x1701
#endif //GL_PROJECTION
#ifndef GL_TEXTURE
#define GL_TEXTURE                                                      0x1702
#endif //GL_TEXTURE

#endif //GL_MatrixMode

#ifndef GL_MeshMode1

#define GL_MeshMode1
#ifndef GL_POINT
#define GL_POINT                                                        0x1B00
#endif //GL_POINT
#ifndef GL_LINE
#define GL_LINE                                                         0x1B01
#endif //GL_LINE

#endif //GL_MeshMode1

#ifndef GL_MeshMode2

#define GL_MeshMode2
#ifndef GL_FILL
#define GL_FILL                                                         0x1B02
#endif //GL_FILL

#endif //GL_MeshMode2

#ifndef GL_MinmaxTargetEXT

#define GL_MinmaxTargetEXT

#endif //GL_MinmaxTargetEXT

#ifndef GL_NV_bindless_texture

#define GL_NV_bindless_texture

#endif //GL_NV_bindless_texture


typedef GLuint64 (*PFNGETTEXTUREHANDLENVPROC_HPP)(GLuint texture);

static inline GLuint64 GetTextureHandleNV(GLuint texture)
{
	static PFNGETTEXTUREHANDLENVPROC_HPP fn=reinterpret_cast<PFNGETTEXTUREHANDLENVPROC_HPP>(_impl::_get_proc_address("glGetTextureHandleNV","GL_NV_bindless_texture"));
	return fn(texture);
}

typedef GLuint64 (*PFNGETTEXTURESAMPLERHANDLENVPROC_HPP)(GLuint texture,GLuint sampler);

static inline GLuint64 GetTextureSamplerHandleNV(GLuint texture,GLuint sampler)
{
	static PFNGETTEXTURESAMPLERHANDLENVPROC_HPP fn=reinterpret_cast<PFNGETTEXTURESAMPLERHANDLENVPROC_HPP>(_impl::_get_proc_address("glGetTextureSamplerHandleNV","GL_NV_bindless_texture"));
	return fn(texture,sampler);
}

typedef void (*PFNMAKETEXTUREHANDLERESIDENTNVPROC_HPP)(GLuint64 handle);

static inline void MakeTextureHandleResidentNV(GLuint64 handle)
{
	static PFNMAKETEXTUREHANDLERESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKETEXTUREHANDLERESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeTextureHandleResidentNV","GL_NV_bindless_texture"));
	 fn(handle);
}

typedef void (*PFNMAKETEXTUREHANDLENONRESIDENTNVPROC_HPP)(GLuint64 handle);

static inline void MakeTextureHandleNonResidentNV(GLuint64 handle)
{
	static PFNMAKETEXTUREHANDLENONRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKETEXTUREHANDLENONRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeTextureHandleNonResidentNV","GL_NV_bindless_texture"));
	 fn(handle);
}

typedef GLuint64 (*PFNGETIMAGEHANDLENVPROC_HPP)(GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum format);

static inline GLuint64 GetImageHandleNV(GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum format)
{
	static PFNGETIMAGEHANDLENVPROC_HPP fn=reinterpret_cast<PFNGETIMAGEHANDLENVPROC_HPP>(_impl::_get_proc_address("glGetImageHandleNV","GL_NV_bindless_texture"));
	return fn(texture,level,layered,layer,format);
}

typedef void (*PFNMAKEIMAGEHANDLERESIDENTNVPROC_HPP)(GLuint64 handle,GLenum access);

static inline void MakeImageHandleResidentNV(GLuint64 handle,GLenum access)
{
	static PFNMAKEIMAGEHANDLERESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKEIMAGEHANDLERESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeImageHandleResidentNV","GL_NV_bindless_texture"));
	 fn(handle,access);
}

typedef void (*PFNMAKEIMAGEHANDLENONRESIDENTNVPROC_HPP)(GLuint64 handle);

static inline void MakeImageHandleNonResidentNV(GLuint64 handle)
{
	static PFNMAKEIMAGEHANDLENONRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKEIMAGEHANDLENONRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeImageHandleNonResidentNV","GL_NV_bindless_texture"));
	 fn(handle);
}

typedef void (*PFNUNIFORMHANDLEUI64NVPROC_HPP)(GLint location,GLuint64 value);

static inline void UniformHandleui64NV(GLint location,GLuint64 value)
{
	static PFNUNIFORMHANDLEUI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORMHANDLEUI64NVPROC_HPP>(_impl::_get_proc_address("glUniformHandleui64NV","GL_NV_bindless_texture"));
	 fn(location,value);
}

typedef void (*PFNUNIFORMHANDLEUI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64 *value);

static inline void UniformHandleui64vNV(GLint location,GLsizei count,const GLuint64 *value)
{
	static PFNUNIFORMHANDLEUI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORMHANDLEUI64VNVPROC_HPP>(_impl::_get_proc_address("glUniformHandleui64vNV","GL_NV_bindless_texture"));
	 fn(location,count,value);
}

typedef void (*PFNPROGRAMUNIFORMHANDLEUI64NVPROC_HPP)(GLuint program,GLint location,GLuint64 value);

static inline void ProgramUniformHandleui64NV(GLuint program,GLint location,GLuint64 value)
{
	static PFNPROGRAMUNIFORMHANDLEUI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMHANDLEUI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniformHandleui64NV","GL_NV_bindless_texture"));
	 fn(program,location,value);
}

typedef void (*PFNPROGRAMUNIFORMHANDLEUI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64 *values);

static inline void ProgramUniformHandleui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64 *values)
{
	static PFNPROGRAMUNIFORMHANDLEUI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMHANDLEUI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniformHandleui64vNV","GL_NV_bindless_texture"));
	 fn(program,location,count,values);
}

typedef GLboolean (*PFNISTEXTUREHANDLERESIDENTNVPROC_HPP)(GLuint64 handle);

static inline GLboolean IsTextureHandleResidentNV(GLuint64 handle)
{
	static PFNISTEXTUREHANDLERESIDENTNVPROC_HPP fn=reinterpret_cast<PFNISTEXTUREHANDLERESIDENTNVPROC_HPP>(_impl::_get_proc_address("glIsTextureHandleResidentNV","GL_NV_bindless_texture"));
	return fn(handle);
}

typedef GLboolean (*PFNISIMAGEHANDLERESIDENTNVPROC_HPP)(GLuint64 handle);

static inline GLboolean IsImageHandleResidentNV(GLuint64 handle)
{
	static PFNISIMAGEHANDLERESIDENTNVPROC_HPP fn=reinterpret_cast<PFNISIMAGEHANDLERESIDENTNVPROC_HPP>(_impl::_get_proc_address("glIsImageHandleResidentNV","GL_NV_bindless_texture"));
	return fn(handle);
}
#ifndef GL_NV_conditional_render

#define GL_NV_conditional_render
#ifndef GL_QUERY_WAIT_NV
#define GL_QUERY_WAIT_NV                                                0x8E13
#endif //GL_QUERY_WAIT_NV
#ifndef GL_QUERY_NO_WAIT_NV
#define GL_QUERY_NO_WAIT_NV                                             0x8E14
#endif //GL_QUERY_NO_WAIT_NV
#ifndef GL_QUERY_BY_REGION_WAIT_NV
#define GL_QUERY_BY_REGION_WAIT_NV                                      0x8E15
#endif //GL_QUERY_BY_REGION_WAIT_NV
#ifndef GL_QUERY_BY_REGION_NO_WAIT_NV
#define GL_QUERY_BY_REGION_NO_WAIT_NV                                   0x8E16
#endif //GL_QUERY_BY_REGION_NO_WAIT_NV

#endif //GL_NV_conditional_render


typedef void (*PFNBEGINCONDITIONALRENDERNVPROC_HPP)(GLuint id,GLenum mode);

static inline void BeginConditionalRenderNV(GLuint id,GLenum mode)
{
	static PFNBEGINCONDITIONALRENDERNVPROC_HPP fn=reinterpret_cast<PFNBEGINCONDITIONALRENDERNVPROC_HPP>(_impl::_get_proc_address("glBeginConditionalRenderNV","GL_NV_conditional_render"));
	 fn(id,mode);
}

typedef void (*PFNENDCONDITIONALRENDERNVPROC_HPP)();

static inline void EndConditionalRenderNV()
{
	static PFNENDCONDITIONALRENDERNVPROC_HPP fn=reinterpret_cast<PFNENDCONDITIONALRENDERNVPROC_HPP>(_impl::_get_proc_address("glEndConditionalRenderNV","GL_NV_conditional_render"));
	 fn();
}
#ifndef GL_NV_copy_depth_to_color

#define GL_NV_copy_depth_to_color
#ifndef GL_DEPTH_STENCIL_TO_RGBA_NV
#define GL_DEPTH_STENCIL_TO_RGBA_NV                                     0x886E
#endif //GL_DEPTH_STENCIL_TO_RGBA_NV
#ifndef GL_DEPTH_STENCIL_TO_BGRA_NV
#define GL_DEPTH_STENCIL_TO_BGRA_NV                                     0x886F
#endif //GL_DEPTH_STENCIL_TO_BGRA_NV

#endif //GL_NV_copy_depth_to_color

#ifndef GL_NV_copy_image

#define GL_NV_copy_image

#endif //GL_NV_copy_image


typedef void (*PFNCOPYIMAGESUBDATANVPROC_HPP)(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei width,GLsizei height,GLsizei depth);

static inline void CopyImageSubDataNV(GLuint srcName,GLenum srcTarget,GLint srcLevel,GLint srcX,GLint srcY,GLint srcZ,GLuint dstName,GLenum dstTarget,GLint dstLevel,GLint dstX,GLint dstY,GLint dstZ,GLsizei width,GLsizei height,GLsizei depth)
{
	static PFNCOPYIMAGESUBDATANVPROC_HPP fn=reinterpret_cast<PFNCOPYIMAGESUBDATANVPROC_HPP>(_impl::_get_proc_address("glCopyImageSubDataNV","GL_NV_copy_image"));
	 fn(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth);
}
#ifndef GL_NV_coverage_sample

#define GL_NV_coverage_sample
#ifndef GL_COVERAGE_COMPONENT_NV
#define GL_COVERAGE_COMPONENT_NV                                        0x8ED0
#endif //GL_COVERAGE_COMPONENT_NV
#ifndef GL_COVERAGE_COMPONENT4_NV
#define GL_COVERAGE_COMPONENT4_NV                                       0x8ED1
#endif //GL_COVERAGE_COMPONENT4_NV
#ifndef GL_COVERAGE_ATTACHMENT_NV
#define GL_COVERAGE_ATTACHMENT_NV                                       0x8ED2
#endif //GL_COVERAGE_ATTACHMENT_NV
#ifndef GL_COVERAGE_BUFFERS_NV
#define GL_COVERAGE_BUFFERS_NV                                          0x8ED3
#endif //GL_COVERAGE_BUFFERS_NV
#ifndef GL_COVERAGE_SAMPLES_NV
#define GL_COVERAGE_SAMPLES_NV                                          0x8ED4
#endif //GL_COVERAGE_SAMPLES_NV
#ifndef GL_COVERAGE_ALL_FRAGMENTS_NV
#define GL_COVERAGE_ALL_FRAGMENTS_NV                                    0x8ED5
#endif //GL_COVERAGE_ALL_FRAGMENTS_NV
#ifndef GL_COVERAGE_EDGE_FRAGMENTS_NV
#define GL_COVERAGE_EDGE_FRAGMENTS_NV                                   0x8ED6
#endif //GL_COVERAGE_EDGE_FRAGMENTS_NV
#ifndef GL_COVERAGE_AUTOMATIC_NV
#define GL_COVERAGE_AUTOMATIC_NV                                        0x8ED7
#endif //GL_COVERAGE_AUTOMATIC_NV

#endif //GL_NV_coverage_sample

#ifndef GL_NV_depth_buffer_float

#define GL_NV_depth_buffer_float
#ifndef GL_DEPTH_COMPONENT32F_NV
#define GL_DEPTH_COMPONENT32F_NV                                        0x8DAB
#endif //GL_DEPTH_COMPONENT32F_NV
#ifndef GL_DEPTH32F_STENCIL8_NV
#define GL_DEPTH32F_STENCIL8_NV                                         0x8DAC
#endif //GL_DEPTH32F_STENCIL8_NV
#ifndef GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV
#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV                            0x8DAD
#endif //GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV
#ifndef GL_DEPTH_BUFFER_FLOAT_MODE_NV
#define GL_DEPTH_BUFFER_FLOAT_MODE_NV                                   0x8DAF
#endif //GL_DEPTH_BUFFER_FLOAT_MODE_NV

#endif //GL_NV_depth_buffer_float


typedef void (*PFNDEPTHRANGEDNVPROC_HPP)(GLdouble zNear,GLdouble zFar);

static inline void DepthRangedNV(GLdouble zNear,GLdouble zFar)
{
	static PFNDEPTHRANGEDNVPROC_HPP fn=reinterpret_cast<PFNDEPTHRANGEDNVPROC_HPP>(_impl::_get_proc_address("glDepthRangedNV","GL_NV_depth_buffer_float"));
	 fn(zNear,zFar);
}

typedef void (*PFNCLEARDEPTHDNVPROC_HPP)(GLdouble depth);

static inline void ClearDepthdNV(GLdouble depth)
{
	static PFNCLEARDEPTHDNVPROC_HPP fn=reinterpret_cast<PFNCLEARDEPTHDNVPROC_HPP>(_impl::_get_proc_address("glClearDepthdNV","GL_NV_depth_buffer_float"));
	 fn(depth);
}

typedef void (*PFNDEPTHBOUNDSDNVPROC_HPP)(GLdouble zmin,GLdouble zmax);

static inline void DepthBoundsdNV(GLdouble zmin,GLdouble zmax)
{
	static PFNDEPTHBOUNDSDNVPROC_HPP fn=reinterpret_cast<PFNDEPTHBOUNDSDNVPROC_HPP>(_impl::_get_proc_address("glDepthBoundsdNV","GL_NV_depth_buffer_float"));
	 fn(zmin,zmax);
}
#ifndef GL_NV_depth_clamp

#define GL_NV_depth_clamp
#ifndef GL_DEPTH_CLAMP_NV
#define GL_DEPTH_CLAMP_NV                                               0x864F
#endif //GL_DEPTH_CLAMP_NV

#endif //GL_NV_depth_clamp

#ifndef GL_NV_depth_nonlinear

#define GL_NV_depth_nonlinear
#ifndef GL_DEPTH_COMPONENT16_NONLINEAR_NV
#define GL_DEPTH_COMPONENT16_NONLINEAR_NV                               0x8E2C
#endif //GL_DEPTH_COMPONENT16_NONLINEAR_NV

#endif //GL_NV_depth_nonlinear

#ifndef GL_NV_draw_buffers

#define GL_NV_draw_buffers
#ifndef GL_MAX_DRAW_BUFFERS_NV
#define GL_MAX_DRAW_BUFFERS_NV                                          0x8824
#endif //GL_MAX_DRAW_BUFFERS_NV
#ifndef GL_DRAW_BUFFER0_NV
#define GL_DRAW_BUFFER0_NV                                              0x8825
#endif //GL_DRAW_BUFFER0_NV
#ifndef GL_DRAW_BUFFER1_NV
#define GL_DRAW_BUFFER1_NV                                              0x8826
#endif //GL_DRAW_BUFFER1_NV
#ifndef GL_DRAW_BUFFER2_NV
#define GL_DRAW_BUFFER2_NV                                              0x8827
#endif //GL_DRAW_BUFFER2_NV
#ifndef GL_DRAW_BUFFER3_NV
#define GL_DRAW_BUFFER3_NV                                              0x8828
#endif //GL_DRAW_BUFFER3_NV
#ifndef GL_DRAW_BUFFER4_NV
#define GL_DRAW_BUFFER4_NV                                              0x8829
#endif //GL_DRAW_BUFFER4_NV
#ifndef GL_DRAW_BUFFER5_NV
#define GL_DRAW_BUFFER5_NV                                              0x882A
#endif //GL_DRAW_BUFFER5_NV
#ifndef GL_DRAW_BUFFER6_NV
#define GL_DRAW_BUFFER6_NV                                              0x882B
#endif //GL_DRAW_BUFFER6_NV
#ifndef GL_DRAW_BUFFER7_NV
#define GL_DRAW_BUFFER7_NV                                              0x882C
#endif //GL_DRAW_BUFFER7_NV
#ifndef GL_DRAW_BUFFER8_NV
#define GL_DRAW_BUFFER8_NV                                              0x882D
#endif //GL_DRAW_BUFFER8_NV
#ifndef GL_DRAW_BUFFER9_NV
#define GL_DRAW_BUFFER9_NV                                              0x882E
#endif //GL_DRAW_BUFFER9_NV
#ifndef GL_DRAW_BUFFER10_NV
#define GL_DRAW_BUFFER10_NV                                             0x882F
#endif //GL_DRAW_BUFFER10_NV
#ifndef GL_DRAW_BUFFER11_NV
#define GL_DRAW_BUFFER11_NV                                             0x8830
#endif //GL_DRAW_BUFFER11_NV
#ifndef GL_DRAW_BUFFER12_NV
#define GL_DRAW_BUFFER12_NV                                             0x8831
#endif //GL_DRAW_BUFFER12_NV
#ifndef GL_DRAW_BUFFER13_NV
#define GL_DRAW_BUFFER13_NV                                             0x8832
#endif //GL_DRAW_BUFFER13_NV
#ifndef GL_DRAW_BUFFER14_NV
#define GL_DRAW_BUFFER14_NV                                             0x8833
#endif //GL_DRAW_BUFFER14_NV
#ifndef GL_DRAW_BUFFER15_NV
#define GL_DRAW_BUFFER15_NV                                             0x8834
#endif //GL_DRAW_BUFFER15_NV
#ifndef GL_COLOR_ATTACHMENT0_NV
#define GL_COLOR_ATTACHMENT0_NV                                         0x8CE0
#endif //GL_COLOR_ATTACHMENT0_NV
#ifndef GL_COLOR_ATTACHMENT1_NV
#define GL_COLOR_ATTACHMENT1_NV                                         0x8CE1
#endif //GL_COLOR_ATTACHMENT1_NV
#ifndef GL_COLOR_ATTACHMENT2_NV
#define GL_COLOR_ATTACHMENT2_NV                                         0x8CE2
#endif //GL_COLOR_ATTACHMENT2_NV
#ifndef GL_COLOR_ATTACHMENT3_NV
#define GL_COLOR_ATTACHMENT3_NV                                         0x8CE3
#endif //GL_COLOR_ATTACHMENT3_NV
#ifndef GL_COLOR_ATTACHMENT4_NV
#define GL_COLOR_ATTACHMENT4_NV                                         0x8CE4
#endif //GL_COLOR_ATTACHMENT4_NV
#ifndef GL_COLOR_ATTACHMENT5_NV
#define GL_COLOR_ATTACHMENT5_NV                                         0x8CE5
#endif //GL_COLOR_ATTACHMENT5_NV
#ifndef GL_COLOR_ATTACHMENT6_NV
#define GL_COLOR_ATTACHMENT6_NV                                         0x8CE6
#endif //GL_COLOR_ATTACHMENT6_NV
#ifndef GL_COLOR_ATTACHMENT7_NV
#define GL_COLOR_ATTACHMENT7_NV                                         0x8CE7
#endif //GL_COLOR_ATTACHMENT7_NV
#ifndef GL_COLOR_ATTACHMENT8_NV
#define GL_COLOR_ATTACHMENT8_NV                                         0x8CE8
#endif //GL_COLOR_ATTACHMENT8_NV
#ifndef GL_COLOR_ATTACHMENT9_NV
#define GL_COLOR_ATTACHMENT9_NV                                         0x8CE9
#endif //GL_COLOR_ATTACHMENT9_NV
#ifndef GL_COLOR_ATTACHMENT10_NV
#define GL_COLOR_ATTACHMENT10_NV                                        0x8CEA
#endif //GL_COLOR_ATTACHMENT10_NV
#ifndef GL_COLOR_ATTACHMENT11_NV
#define GL_COLOR_ATTACHMENT11_NV                                        0x8CEB
#endif //GL_COLOR_ATTACHMENT11_NV
#ifndef GL_COLOR_ATTACHMENT12_NV
#define GL_COLOR_ATTACHMENT12_NV                                        0x8CEC
#endif //GL_COLOR_ATTACHMENT12_NV
#ifndef GL_COLOR_ATTACHMENT13_NV
#define GL_COLOR_ATTACHMENT13_NV                                        0x8CED
#endif //GL_COLOR_ATTACHMENT13_NV
#ifndef GL_COLOR_ATTACHMENT14_NV
#define GL_COLOR_ATTACHMENT14_NV                                        0x8CEE
#endif //GL_COLOR_ATTACHMENT14_NV
#ifndef GL_COLOR_ATTACHMENT15_NV
#define GL_COLOR_ATTACHMENT15_NV                                        0x8CEF
#endif //GL_COLOR_ATTACHMENT15_NV

#endif //GL_NV_draw_buffers

#ifndef GL_NV_evaluators

#define GL_NV_evaluators
#ifndef GL_EVAL_2D_NV
#define GL_EVAL_2D_NV                                                   0x86C0
#endif //GL_EVAL_2D_NV
#ifndef GL_EVAL_TRIANGULAR_2D_NV
#define GL_EVAL_TRIANGULAR_2D_NV                                        0x86C1
#endif //GL_EVAL_TRIANGULAR_2D_NV
#ifndef GL_MAP_TESSELLATION_NV
#define GL_MAP_TESSELLATION_NV                                          0x86C2
#endif //GL_MAP_TESSELLATION_NV
#ifndef GL_MAP_ATTRIB_U_ORDER_NV
#define GL_MAP_ATTRIB_U_ORDER_NV                                        0x86C3
#endif //GL_MAP_ATTRIB_U_ORDER_NV
#ifndef GL_MAP_ATTRIB_V_ORDER_NV
#define GL_MAP_ATTRIB_V_ORDER_NV                                        0x86C4
#endif //GL_MAP_ATTRIB_V_ORDER_NV
#ifndef GL_EVAL_FRACTIONAL_TESSELLATION_NV
#define GL_EVAL_FRACTIONAL_TESSELLATION_NV                              0x86C5
#endif //GL_EVAL_FRACTIONAL_TESSELLATION_NV
#ifndef GL_EVAL_VERTEX_ATRRIB0_NV
#define GL_EVAL_VERTEX_ATRRIB0_NV                                       0x86C6
#endif //GL_EVAL_VERTEX_ATRRIB0_NV
#ifndef GL_EVAL_VERTEX_ATRRIB1_NV
#define GL_EVAL_VERTEX_ATRRIB1_NV                                       0x86C7
#endif //GL_EVAL_VERTEX_ATRRIB1_NV
#ifndef GL_EVAL_VERTEX_ATRRIB2_NV
#define GL_EVAL_VERTEX_ATRRIB2_NV                                       0x86C8
#endif //GL_EVAL_VERTEX_ATRRIB2_NV
#ifndef GL_EVAL_VERTEX_ATRRIB3_NV
#define GL_EVAL_VERTEX_ATRRIB3_NV                                       0x86C9
#endif //GL_EVAL_VERTEX_ATRRIB3_NV
#ifndef GL_EVAL_VERTEX_ATRRIB4_NV
#define GL_EVAL_VERTEX_ATRRIB4_NV                                       0x86CA
#endif //GL_EVAL_VERTEX_ATRRIB4_NV
#ifndef GL_EVAL_VERTEX_ATRRIB5_NV
#define GL_EVAL_VERTEX_ATRRIB5_NV                                       0x86CB
#endif //GL_EVAL_VERTEX_ATRRIB5_NV
#ifndef GL_EVAL_VERTEX_ATRRIB6_NV
#define GL_EVAL_VERTEX_ATRRIB6_NV                                       0x86CC
#endif //GL_EVAL_VERTEX_ATRRIB6_NV
#ifndef GL_EVAL_VERTEX_ATRRIB7_NV
#define GL_EVAL_VERTEX_ATRRIB7_NV                                       0x86CD
#endif //GL_EVAL_VERTEX_ATRRIB7_NV
#ifndef GL_EVAL_VERTEX_ATRRIB8_NV
#define GL_EVAL_VERTEX_ATRRIB8_NV                                       0x86CE
#endif //GL_EVAL_VERTEX_ATRRIB8_NV
#ifndef GL_EVAL_VERTEX_ATRRIB9_NV
#define GL_EVAL_VERTEX_ATRRIB9_NV                                       0x86CF
#endif //GL_EVAL_VERTEX_ATRRIB9_NV
#ifndef GL_EVAL_VERTEX_ATRRIB10_NV
#define GL_EVAL_VERTEX_ATRRIB10_NV                                      0x86D0
#endif //GL_EVAL_VERTEX_ATRRIB10_NV
#ifndef GL_EVAL_VERTEX_ATRRIB11_NV
#define GL_EVAL_VERTEX_ATRRIB11_NV                                      0x86D1
#endif //GL_EVAL_VERTEX_ATRRIB11_NV
#ifndef GL_EVAL_VERTEX_ATRRIB12_NV
#define GL_EVAL_VERTEX_ATRRIB12_NV                                      0x86D2
#endif //GL_EVAL_VERTEX_ATRRIB12_NV
#ifndef GL_EVAL_VERTEX_ATRRIB13_NV
#define GL_EVAL_VERTEX_ATRRIB13_NV                                      0x86D3
#endif //GL_EVAL_VERTEX_ATRRIB13_NV
#ifndef GL_EVAL_VERTEX_ATRRIB14_NV
#define GL_EVAL_VERTEX_ATRRIB14_NV                                      0x86D4
#endif //GL_EVAL_VERTEX_ATRRIB14_NV
#ifndef GL_EVAL_VERTEX_ATRRIB15_NV
#define GL_EVAL_VERTEX_ATRRIB15_NV                                      0x86D5
#endif //GL_EVAL_VERTEX_ATRRIB15_NV
#ifndef GL_MAX_MAP_TESSELLATION_NV
#define GL_MAX_MAP_TESSELLATION_NV                                      0x86D6
#endif //GL_MAX_MAP_TESSELLATION_NV
#ifndef GL_MAX_RATIONAL_EVAL_ORDER_NV
#define GL_MAX_RATIONAL_EVAL_ORDER_NV                                   0x86D7
#endif //GL_MAX_RATIONAL_EVAL_ORDER_NV

#endif //GL_NV_evaluators


typedef void (*PFNMAPCONTROLPOINTSNVPROC_HPP)(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLint uorder,GLint vorder,GLboolean packed,const GLvoid *points);

static inline void MapControlPointsNV(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLint uorder,GLint vorder,GLboolean packed,const GLvoid *points)
{
	static PFNMAPCONTROLPOINTSNVPROC_HPP fn=reinterpret_cast<PFNMAPCONTROLPOINTSNVPROC_HPP>(_impl::_get_proc_address("glMapControlPointsNV","GL_NV_evaluators"));
	 fn(target,index,type,ustride,vstride,uorder,vorder,packed,points);
}

typedef void (*PFNMAPPARAMETERIVNVPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void MapParameterivNV(GLenum target,GLenum pname,const GLint *params)
{
	static PFNMAPPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNMAPPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glMapParameterivNV","GL_NV_evaluators"));
	 fn(target,pname,params);
}

typedef void (*PFNMAPPARAMETERFVNVPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void MapParameterfvNV(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNMAPPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNMAPPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glMapParameterfvNV","GL_NV_evaluators"));
	 fn(target,pname,params);
}

typedef void (*PFNGETMAPCONTROLPOINTSNVPROC_HPP)(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLboolean packed,GLvoid *points);

static inline void GetMapControlPointsNV(GLenum target,GLuint index,GLenum type,GLsizei ustride,GLsizei vstride,GLboolean packed,GLvoid *points)
{
	static PFNGETMAPCONTROLPOINTSNVPROC_HPP fn=reinterpret_cast<PFNGETMAPCONTROLPOINTSNVPROC_HPP>(_impl::_get_proc_address("glGetMapControlPointsNV","GL_NV_evaluators"));
	 fn(target,index,type,ustride,vstride,packed,points);
}

typedef void (*PFNGETMAPPARAMETERIVNVPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetMapParameterivNV(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETMAPPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETMAPPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetMapParameterivNV","GL_NV_evaluators"));
	 fn(target,pname,params);
}

typedef void (*PFNGETMAPPARAMETERFVNVPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetMapParameterfvNV(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETMAPPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETMAPPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetMapParameterfvNV","GL_NV_evaluators"));
	 fn(target,pname,params);
}

typedef void (*PFNGETMAPATTRIBPARAMETERIVNVPROC_HPP)(GLenum target,GLuint index,GLenum pname,GLint *params);

static inline void GetMapAttribParameterivNV(GLenum target,GLuint index,GLenum pname,GLint *params)
{
	static PFNGETMAPATTRIBPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETMAPATTRIBPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetMapAttribParameterivNV","GL_NV_evaluators"));
	 fn(target,index,pname,params);
}

typedef void (*PFNGETMAPATTRIBPARAMETERFVNVPROC_HPP)(GLenum target,GLuint index,GLenum pname,GLfloat *params);

static inline void GetMapAttribParameterfvNV(GLenum target,GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETMAPATTRIBPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETMAPATTRIBPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetMapAttribParameterfvNV","GL_NV_evaluators"));
	 fn(target,index,pname,params);
}

typedef void (*PFNEVALMAPSNVPROC_HPP)(GLenum target,GLenum mode);

static inline void EvalMapsNV(GLenum target,GLenum mode)
{
	static PFNEVALMAPSNVPROC_HPP fn=reinterpret_cast<PFNEVALMAPSNVPROC_HPP>(_impl::_get_proc_address("glEvalMapsNV","GL_NV_evaluators"));
	 fn(target,mode);
}
#ifndef GL_NV_explicit_multisample

#define GL_NV_explicit_multisample
#ifndef GL_SAMPLE_POSITION_NV
#define GL_SAMPLE_POSITION_NV                                           0x8E50
#endif //GL_SAMPLE_POSITION_NV
#ifndef GL_SAMPLE_MASK_NV
#define GL_SAMPLE_MASK_NV                                               0x8E51
#endif //GL_SAMPLE_MASK_NV
#ifndef GL_SAMPLE_MASK_VALUE_NV
#define GL_SAMPLE_MASK_VALUE_NV                                         0x8E52
#endif //GL_SAMPLE_MASK_VALUE_NV
#ifndef GL_TEXTURE_BINDING_RENDERBUFFER_NV
#define GL_TEXTURE_BINDING_RENDERBUFFER_NV                              0x8E53
#endif //GL_TEXTURE_BINDING_RENDERBUFFER_NV
#ifndef GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV
#define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV                   0x8E54
#endif //GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV
#ifndef GL_TEXTURE_RENDERBUFFER_NV
#define GL_TEXTURE_RENDERBUFFER_NV                                      0x8E55
#endif //GL_TEXTURE_RENDERBUFFER_NV
#ifndef GL_SAMPLER_RENDERBUFFER_NV
#define GL_SAMPLER_RENDERBUFFER_NV                                      0x8E56
#endif //GL_SAMPLER_RENDERBUFFER_NV
#ifndef GL_INT_SAMPLER_RENDERBUFFER_NV
#define GL_INT_SAMPLER_RENDERBUFFER_NV                                  0x8E57
#endif //GL_INT_SAMPLER_RENDERBUFFER_NV
#ifndef GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV
#define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV                         0x8E58
#endif //GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV
#ifndef GL_MAX_SAMPLE_MASK_WORDS_NV
#define GL_MAX_SAMPLE_MASK_WORDS_NV                                     0x8E59
#endif //GL_MAX_SAMPLE_MASK_WORDS_NV

#endif //GL_NV_explicit_multisample


typedef void (*PFNGETMULTISAMPLEFVNVPROC_HPP)(GLenum pname,GLuint index,GLfloat *val);

static inline void GetMultisamplefvNV(GLenum pname,GLuint index,GLfloat *val)
{
	static PFNGETMULTISAMPLEFVNVPROC_HPP fn=reinterpret_cast<PFNGETMULTISAMPLEFVNVPROC_HPP>(_impl::_get_proc_address("glGetMultisamplefvNV","GL_NV_explicit_multisample"));
	 fn(pname,index,val);
}

typedef void (*PFNSAMPLEMASKINDEXEDNVPROC_HPP)(GLuint index,GLbitfield mask);

static inline void SampleMaskIndexedNV(GLuint index,GLbitfield mask)
{
	static PFNSAMPLEMASKINDEXEDNVPROC_HPP fn=reinterpret_cast<PFNSAMPLEMASKINDEXEDNVPROC_HPP>(_impl::_get_proc_address("glSampleMaskIndexedNV","GL_NV_explicit_multisample"));
	 fn(index,mask);
}

typedef void (*PFNTEXRENDERBUFFERNVPROC_HPP)(GLenum target,GLuint renderbuffer);

static inline void TexRenderbufferNV(GLenum target,GLuint renderbuffer)
{
	static PFNTEXRENDERBUFFERNVPROC_HPP fn=reinterpret_cast<PFNTEXRENDERBUFFERNVPROC_HPP>(_impl::_get_proc_address("glTexRenderbufferNV","GL_NV_explicit_multisample"));
	 fn(target,renderbuffer);
}
#ifndef GL_NV_fbo_color_attachments

#define GL_NV_fbo_color_attachments
#ifndef GL_MAX_COLOR_ATTACHMENTS_NV
#define GL_MAX_COLOR_ATTACHMENTS_NV                                     0x8CDF
#endif //GL_MAX_COLOR_ATTACHMENTS_NV

#endif //GL_NV_fbo_color_attachments

#ifndef GL_NV_fence

#define GL_NV_fence
#ifndef GL_ALL_COMPLETED_NV
#define GL_ALL_COMPLETED_NV                                             0x84F2
#endif //GL_ALL_COMPLETED_NV
#ifndef GL_FENCE_STATUS_NV
#define GL_FENCE_STATUS_NV                                              0x84F3
#endif //GL_FENCE_STATUS_NV
#ifndef GL_FENCE_CONDITION_NV
#define GL_FENCE_CONDITION_NV                                           0x84F4
#endif //GL_FENCE_CONDITION_NV

#endif //GL_NV_fence


typedef void (*PFNDELETEFENCESNVPROC_HPP)(GLsizei n,const GLuint *fences);

static inline void DeleteFencesNV(GLsizei n,const GLuint *fences)
{
	static PFNDELETEFENCESNVPROC_HPP fn=reinterpret_cast<PFNDELETEFENCESNVPROC_HPP>(_impl::_get_proc_address("glDeleteFencesNV","GL_NV_fence"));
	 fn(n,fences);
}

typedef void (*PFNGENFENCESNVPROC_HPP)(GLsizei n,GLuint *fences);

static inline void GenFencesNV(GLsizei n,GLuint *fences)
{
	static PFNGENFENCESNVPROC_HPP fn=reinterpret_cast<PFNGENFENCESNVPROC_HPP>(_impl::_get_proc_address("glGenFencesNV","GL_NV_fence"));
	 fn(n,fences);
}

typedef GLboolean (*PFNISFENCENVPROC_HPP)(GLuint fence);

static inline GLboolean IsFenceNV(GLuint fence)
{
	static PFNISFENCENVPROC_HPP fn=reinterpret_cast<PFNISFENCENVPROC_HPP>(_impl::_get_proc_address("glIsFenceNV","GL_NV_fence"));
	return fn(fence);
}

typedef GLboolean (*PFNTESTFENCENVPROC_HPP)(GLuint fence);

static inline GLboolean TestFenceNV(GLuint fence)
{
	static PFNTESTFENCENVPROC_HPP fn=reinterpret_cast<PFNTESTFENCENVPROC_HPP>(_impl::_get_proc_address("glTestFenceNV","GL_NV_fence"));
	return fn(fence);
}

typedef void (*PFNGETFENCEIVNVPROC_HPP)(GLuint fence,GLenum pname,GLint *params);

static inline void GetFenceivNV(GLuint fence,GLenum pname,GLint *params)
{
	static PFNGETFENCEIVNVPROC_HPP fn=reinterpret_cast<PFNGETFENCEIVNVPROC_HPP>(_impl::_get_proc_address("glGetFenceivNV","GL_NV_fence"));
	 fn(fence,pname,params);
}

typedef void (*PFNFINISHFENCENVPROC_HPP)(GLuint fence);

static inline void FinishFenceNV(GLuint fence)
{
	static PFNFINISHFENCENVPROC_HPP fn=reinterpret_cast<PFNFINISHFENCENVPROC_HPP>(_impl::_get_proc_address("glFinishFenceNV","GL_NV_fence"));
	 fn(fence);
}

typedef void (*PFNSETFENCENVPROC_HPP)(GLuint fence,GLenum condition);

static inline void SetFenceNV(GLuint fence,GLenum condition)
{
	static PFNSETFENCENVPROC_HPP fn=reinterpret_cast<PFNSETFENCENVPROC_HPP>(_impl::_get_proc_address("glSetFenceNV","GL_NV_fence"));
	 fn(fence,condition);
}
#ifndef GL_NV_float_buffer

#define GL_NV_float_buffer
#ifndef GL_FLOAT_R_NV
#define GL_FLOAT_R_NV                                                   0x8880
#endif //GL_FLOAT_R_NV
#ifndef GL_FLOAT_RG_NV
#define GL_FLOAT_RG_NV                                                  0x8881
#endif //GL_FLOAT_RG_NV
#ifndef GL_FLOAT_RGB_NV
#define GL_FLOAT_RGB_NV                                                 0x8882
#endif //GL_FLOAT_RGB_NV
#ifndef GL_FLOAT_RGBA_NV
#define GL_FLOAT_RGBA_NV                                                0x8883
#endif //GL_FLOAT_RGBA_NV
#ifndef GL_FLOAT_R16_NV
#define GL_FLOAT_R16_NV                                                 0x8884
#endif //GL_FLOAT_R16_NV
#ifndef GL_FLOAT_R32_NV
#define GL_FLOAT_R32_NV                                                 0x8885
#endif //GL_FLOAT_R32_NV
#ifndef GL_FLOAT_RG16_NV
#define GL_FLOAT_RG16_NV                                                0x8886
#endif //GL_FLOAT_RG16_NV
#ifndef GL_FLOAT_RG32_NV
#define GL_FLOAT_RG32_NV                                                0x8887
#endif //GL_FLOAT_RG32_NV
#ifndef GL_FLOAT_RGB16_NV
#define GL_FLOAT_RGB16_NV                                               0x8888
#endif //GL_FLOAT_RGB16_NV
#ifndef GL_FLOAT_RGB32_NV
#define GL_FLOAT_RGB32_NV                                               0x8889
#endif //GL_FLOAT_RGB32_NV
#ifndef GL_FLOAT_RGBA16_NV
#define GL_FLOAT_RGBA16_NV                                              0x888A
#endif //GL_FLOAT_RGBA16_NV
#ifndef GL_FLOAT_RGBA32_NV
#define GL_FLOAT_RGBA32_NV                                              0x888B
#endif //GL_FLOAT_RGBA32_NV
#ifndef GL_TEXTURE_FLOAT_COMPONENTS_NV
#define GL_TEXTURE_FLOAT_COMPONENTS_NV                                  0x888C
#endif //GL_TEXTURE_FLOAT_COMPONENTS_NV
#ifndef GL_FLOAT_CLEAR_COLOR_VALUE_NV
#define GL_FLOAT_CLEAR_COLOR_VALUE_NV                                   0x888D
#endif //GL_FLOAT_CLEAR_COLOR_VALUE_NV
#ifndef GL_FLOAT_RGBA_MODE_NV
#define GL_FLOAT_RGBA_MODE_NV                                           0x888E
#endif //GL_FLOAT_RGBA_MODE_NV

#endif //GL_NV_float_buffer

#ifndef GL_NV_fog_distance

#define GL_NV_fog_distance
#ifndef GL_FOG_GEN_MODE_NV
#define GL_FOG_GEN_MODE_NV                                              0x855A
#endif //GL_FOG_GEN_MODE_NV
#ifndef GL_EYE_RADIAL_NV
#define GL_EYE_RADIAL_NV                                                0x855B
#endif //GL_EYE_RADIAL_NV
#ifndef GL_EYE_PLANE_ABSOLUTE_NV
#define GL_EYE_PLANE_ABSOLUTE_NV                                        0x855C
#endif //GL_EYE_PLANE_ABSOLUTE_NV

#endif //GL_NV_fog_distance

#ifndef GL_NV_fragment_program

#define GL_NV_fragment_program
#ifndef GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV
#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV                     0x8868
#endif //GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV
#ifndef GL_FRAGMENT_PROGRAM_NV
#define GL_FRAGMENT_PROGRAM_NV                                          0x8870
#endif //GL_FRAGMENT_PROGRAM_NV
#ifndef GL_MAX_TEXTURE_COORDS_NV
#define GL_MAX_TEXTURE_COORDS_NV                                        0x8871
#endif //GL_MAX_TEXTURE_COORDS_NV
#ifndef GL_MAX_TEXTURE_IMAGE_UNITS_NV
#define GL_MAX_TEXTURE_IMAGE_UNITS_NV                                   0x8872
#endif //GL_MAX_TEXTURE_IMAGE_UNITS_NV
#ifndef GL_FRAGMENT_PROGRAM_BINDING_NV
#define GL_FRAGMENT_PROGRAM_BINDING_NV                                  0x8873
#endif //GL_FRAGMENT_PROGRAM_BINDING_NV
#ifndef GL_PROGRAM_ERROR_STRING_NV
#define GL_PROGRAM_ERROR_STRING_NV                                      0x8874
#endif //GL_PROGRAM_ERROR_STRING_NV

#endif //GL_NV_fragment_program


typedef void (*PFNPROGRAMNAMEDPARAMETER4FNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void ProgramNamedParameter4fNV(GLuint id,GLsizei len,const GLubyte *name,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNPROGRAMNAMEDPARAMETER4FNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMNAMEDPARAMETER4FNVPROC_HPP>(_impl::_get_proc_address("glProgramNamedParameter4fNV","GL_NV_fragment_program"));
	 fn(id,len,name,x,y,z,w);
}

typedef void (*PFNPROGRAMNAMEDPARAMETER4DNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void ProgramNamedParameter4dNV(GLuint id,GLsizei len,const GLubyte *name,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNPROGRAMNAMEDPARAMETER4DNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMNAMEDPARAMETER4DNVPROC_HPP>(_impl::_get_proc_address("glProgramNamedParameter4dNV","GL_NV_fragment_program"));
	 fn(id,len,name,x,y,z,w);
}

typedef void (*PFNPROGRAMNAMEDPARAMETER4FVNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,const GLfloat *v);

static inline void ProgramNamedParameter4fvNV(GLuint id,GLsizei len,const GLubyte *name,const GLfloat *v)
{
	static PFNPROGRAMNAMEDPARAMETER4FVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMNAMEDPARAMETER4FVNVPROC_HPP>(_impl::_get_proc_address("glProgramNamedParameter4fvNV","GL_NV_fragment_program"));
	 fn(id,len,name,v);
}

typedef void (*PFNPROGRAMNAMEDPARAMETER4DVNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,const GLdouble *v);

static inline void ProgramNamedParameter4dvNV(GLuint id,GLsizei len,const GLubyte *name,const GLdouble *v)
{
	static PFNPROGRAMNAMEDPARAMETER4DVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMNAMEDPARAMETER4DVNVPROC_HPP>(_impl::_get_proc_address("glProgramNamedParameter4dvNV","GL_NV_fragment_program"));
	 fn(id,len,name,v);
}

typedef void (*PFNGETPROGRAMNAMEDPARAMETERFVNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,GLfloat *params);

static inline void GetProgramNamedParameterfvNV(GLuint id,GLsizei len,const GLubyte *name,GLfloat *params)
{
	static PFNGETPROGRAMNAMEDPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMNAMEDPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramNamedParameterfvNV","GL_NV_fragment_program"));
	 fn(id,len,name,params);
}

typedef void (*PFNGETPROGRAMNAMEDPARAMETERDVNVPROC_HPP)(GLuint id,GLsizei len,const GLubyte *name,GLdouble *params);

static inline void GetProgramNamedParameterdvNV(GLuint id,GLsizei len,const GLubyte *name,GLdouble *params)
{
	static PFNGETPROGRAMNAMEDPARAMETERDVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMNAMEDPARAMETERDVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramNamedParameterdvNV","GL_NV_fragment_program"));
	 fn(id,len,name,params);
}
#ifndef GL_NV_fragment_program2

#define GL_NV_fragment_program2
#ifndef GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV
#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV                             0x88F4
#endif //GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV
#ifndef GL_MAX_PROGRAM_CALL_DEPTH_NV
#define GL_MAX_PROGRAM_CALL_DEPTH_NV                                    0x88F5
#endif //GL_MAX_PROGRAM_CALL_DEPTH_NV
#ifndef GL_MAX_PROGRAM_IF_DEPTH_NV
#define GL_MAX_PROGRAM_IF_DEPTH_NV                                      0x88F6
#endif //GL_MAX_PROGRAM_IF_DEPTH_NV
#ifndef GL_MAX_PROGRAM_LOOP_DEPTH_NV
#define GL_MAX_PROGRAM_LOOP_DEPTH_NV                                    0x88F7
#endif //GL_MAX_PROGRAM_LOOP_DEPTH_NV
#ifndef GL_MAX_PROGRAM_LOOP_COUNT_NV
#define GL_MAX_PROGRAM_LOOP_COUNT_NV                                    0x88F8
#endif //GL_MAX_PROGRAM_LOOP_COUNT_NV

#endif //GL_NV_fragment_program2

#ifndef GL_NV_framebuffer_multisample_coverage

#define GL_NV_framebuffer_multisample_coverage
#ifndef GL_RENDERBUFFER_COVERAGE_SAMPLES_NV
#define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV                             0x8CAB
#endif //GL_RENDERBUFFER_COVERAGE_SAMPLES_NV
#ifndef GL_RENDERBUFFER_COLOR_SAMPLES_NV
#define GL_RENDERBUFFER_COLOR_SAMPLES_NV                                0x8E10
#endif //GL_RENDERBUFFER_COLOR_SAMPLES_NV
#ifndef GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV
#define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV                            0x8E11
#endif //GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV
#ifndef GL_MULTISAMPLE_COVERAGE_MODES_NV
#define GL_MULTISAMPLE_COVERAGE_MODES_NV                                0x8E12
#endif //GL_MULTISAMPLE_COVERAGE_MODES_NV

#endif //GL_NV_framebuffer_multisample_coverage


typedef void (*PFNRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC_HPP)(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height);

static inline void RenderbufferStorageMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLenum internalformat,GLsizei width,GLsizei height)
{
	static PFNRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC_HPP fn=reinterpret_cast<PFNRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC_HPP>(_impl::_get_proc_address("glRenderbufferStorageMultisampleCoverageNV","GL_NV_framebuffer_multisample_coverage"));
	 fn(target,coverageSamples,colorSamples,internalformat,width,height);
}
#ifndef GL_NV_geometry_program4

#define GL_NV_geometry_program4
#ifndef GL_LINES_ADJACENCY_EXT
#define GL_LINES_ADJACENCY_EXT                                          0x000A
#endif //GL_LINES_ADJACENCY_EXT
#ifndef GL_LINE_STRIP_ADJACENCY_EXT
#define GL_LINE_STRIP_ADJACENCY_EXT                                     0x000B
#endif //GL_LINE_STRIP_ADJACENCY_EXT
#ifndef GL_TRIANGLES_ADJACENCY_EXT
#define GL_TRIANGLES_ADJACENCY_EXT                                      0x000C
#endif //GL_TRIANGLES_ADJACENCY_EXT
#ifndef GL_TRIANGLE_STRIP_ADJACENCY_EXT
#define GL_TRIANGLE_STRIP_ADJACENCY_EXT                                 0x000D
#endif //GL_TRIANGLE_STRIP_ADJACENCY_EXT
#ifndef GL_PROGRAM_POINT_SIZE_EXT
#define GL_PROGRAM_POINT_SIZE_EXT                                       0x8642
#endif //GL_PROGRAM_POINT_SIZE_EXT
#ifndef GL_GEOMETRY_PROGRAM_NV
#define GL_GEOMETRY_PROGRAM_NV                                          0x8C26
#endif //GL_GEOMETRY_PROGRAM_NV
#ifndef GL_MAX_PROGRAM_OUTPUT_VERTICES_NV
#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV                               0x8C27
#endif //GL_MAX_PROGRAM_OUTPUT_VERTICES_NV
#ifndef GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV
#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV                       0x8C28
#endif //GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV
#ifndef GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT
#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT                         0x8C29
#endif //GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT                     0x8CD4
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT
#ifndef GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT
#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT                           0x8DA7
#endif //GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT                     0x8DA8
#endif //GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT
#ifndef GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT                       0x8DA9
#endif //GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT
#ifndef GL_GEOMETRY_VERTICES_OUT_EXT
#define GL_GEOMETRY_VERTICES_OUT_EXT                                    0x8DDA
#endif //GL_GEOMETRY_VERTICES_OUT_EXT
#ifndef GL_GEOMETRY_INPUT_TYPE_EXT
#define GL_GEOMETRY_INPUT_TYPE_EXT                                      0x8DDB
#endif //GL_GEOMETRY_INPUT_TYPE_EXT
#ifndef GL_GEOMETRY_OUTPUT_TYPE_EXT
#define GL_GEOMETRY_OUTPUT_TYPE_EXT                                     0x8DDC
#endif //GL_GEOMETRY_OUTPUT_TYPE_EXT

#endif //GL_NV_geometry_program4


typedef void (*PFNPROGRAMVERTEXLIMITNVPROC_HPP)(GLenum target,GLint limit);

static inline void ProgramVertexLimitNV(GLenum target,GLint limit)
{
	static PFNPROGRAMVERTEXLIMITNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMVERTEXLIMITNVPROC_HPP>(_impl::_get_proc_address("glProgramVertexLimitNV","GL_NV_geometry_program4"));
	 fn(target,limit);
}

typedef void (*PFNFRAMEBUFFERTEXTUREEXTPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level);

static inline void FramebufferTextureEXT(GLenum target,GLenum attachment,GLuint texture,GLint level)
{
	static PFNFRAMEBUFFERTEXTUREEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTUREEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureEXT","GL_NV_geometry_program4"));
	 fn(target,attachment,texture,level);
}

typedef void (*PFNFRAMEBUFFERTEXTURELAYEREXTPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer);

static inline void FramebufferTextureLayerEXT(GLenum target,GLenum attachment,GLuint texture,GLint level,GLint layer)
{
	static PFNFRAMEBUFFERTEXTURELAYEREXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTURELAYEREXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureLayerEXT","GL_NV_geometry_program4"));
	 fn(target,attachment,texture,level,layer);
}

typedef void (*PFNFRAMEBUFFERTEXTUREFACEEXTPROC_HPP)(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face);

static inline void FramebufferTextureFaceEXT(GLenum target,GLenum attachment,GLuint texture,GLint level,GLenum face)
{
	static PFNFRAMEBUFFERTEXTUREFACEEXTPROC_HPP fn=reinterpret_cast<PFNFRAMEBUFFERTEXTUREFACEEXTPROC_HPP>(_impl::_get_proc_address("glFramebufferTextureFaceEXT","GL_NV_geometry_program4"));
	 fn(target,attachment,texture,level,face);
}
#ifndef GL_NV_gpu_program4

#define GL_NV_gpu_program4
#ifndef GL_MIN_PROGRAM_TEXEL_OFFSET_NV
#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV                                  0x8904
#endif //GL_MIN_PROGRAM_TEXEL_OFFSET_NV
#ifndef GL_MAX_PROGRAM_TEXEL_OFFSET_NV
#define GL_MAX_PROGRAM_TEXEL_OFFSET_NV                                  0x8905
#endif //GL_MAX_PROGRAM_TEXEL_OFFSET_NV
#ifndef GL_PROGRAM_ATTRIB_COMPONENTS_NV
#define GL_PROGRAM_ATTRIB_COMPONENTS_NV                                 0x8906
#endif //GL_PROGRAM_ATTRIB_COMPONENTS_NV
#ifndef GL_PROGRAM_RESULT_COMPONENTS_NV
#define GL_PROGRAM_RESULT_COMPONENTS_NV                                 0x8907
#endif //GL_PROGRAM_RESULT_COMPONENTS_NV
#ifndef GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV
#define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV                             0x8908
#endif //GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV
#ifndef GL_MAX_PROGRAM_RESULT_COMPONENTS_NV
#define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV                             0x8909
#endif //GL_MAX_PROGRAM_RESULT_COMPONENTS_NV
#ifndef GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV
#define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV                               0x8DA5
#endif //GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV
#ifndef GL_MAX_PROGRAM_GENERIC_RESULTS_NV
#define GL_MAX_PROGRAM_GENERIC_RESULTS_NV                               0x8DA6
#endif //GL_MAX_PROGRAM_GENERIC_RESULTS_NV

#endif //GL_NV_gpu_program4


typedef void (*PFNPROGRAMLOCALPARAMETERI4INVPROC_HPP)(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);

static inline void ProgramLocalParameterI4iNV(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w)
{
	static PFNPROGRAMLOCALPARAMETERI4INVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERI4INVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameterI4iNV","GL_NV_gpu_program4"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMLOCALPARAMETERI4IVNVPROC_HPP)(GLenum target,GLuint index,const GLint *params);

static inline void ProgramLocalParameterI4ivNV(GLenum target,GLuint index,const GLint *params)
{
	static PFNPROGRAMLOCALPARAMETERI4IVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERI4IVNVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameterI4ivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETERSI4IVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLint *params);

static inline void ProgramLocalParametersI4ivNV(GLenum target,GLuint index,GLsizei count,const GLint *params)
{
	static PFNPROGRAMLOCALPARAMETERSI4IVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERSI4IVNVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParametersI4ivNV","GL_NV_gpu_program4"));
	 fn(target,index,count,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETERI4UINVPROC_HPP)(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);

static inline void ProgramLocalParameterI4uiNV(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)
{
	static PFNPROGRAMLOCALPARAMETERI4UINVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERI4UINVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameterI4uiNV","GL_NV_gpu_program4"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMLOCALPARAMETERI4UIVNVPROC_HPP)(GLenum target,GLuint index,const GLuint *params);

static inline void ProgramLocalParameterI4uivNV(GLenum target,GLuint index,const GLuint *params)
{
	static PFNPROGRAMLOCALPARAMETERI4UIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERI4UIVNVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParameterI4uivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMLOCALPARAMETERSI4UIVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLuint *params);

static inline void ProgramLocalParametersI4uivNV(GLenum target,GLuint index,GLsizei count,const GLuint *params)
{
	static PFNPROGRAMLOCALPARAMETERSI4UIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMLOCALPARAMETERSI4UIVNVPROC_HPP>(_impl::_get_proc_address("glProgramLocalParametersI4uivNV","GL_NV_gpu_program4"));
	 fn(target,index,count,params);
}

typedef void (*PFNPROGRAMENVPARAMETERI4INVPROC_HPP)(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w);

static inline void ProgramEnvParameterI4iNV(GLenum target,GLuint index,GLint x,GLint y,GLint z,GLint w)
{
	static PFNPROGRAMENVPARAMETERI4INVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERI4INVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameterI4iNV","GL_NV_gpu_program4"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMENVPARAMETERI4IVNVPROC_HPP)(GLenum target,GLuint index,const GLint *params);

static inline void ProgramEnvParameterI4ivNV(GLenum target,GLuint index,const GLint *params)
{
	static PFNPROGRAMENVPARAMETERI4IVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERI4IVNVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameterI4ivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMENVPARAMETERSI4IVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLint *params);

static inline void ProgramEnvParametersI4ivNV(GLenum target,GLuint index,GLsizei count,const GLint *params)
{
	static PFNPROGRAMENVPARAMETERSI4IVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERSI4IVNVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParametersI4ivNV","GL_NV_gpu_program4"));
	 fn(target,index,count,params);
}

typedef void (*PFNPROGRAMENVPARAMETERI4UINVPROC_HPP)(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);

static inline void ProgramEnvParameterI4uiNV(GLenum target,GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)
{
	static PFNPROGRAMENVPARAMETERI4UINVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERI4UINVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameterI4uiNV","GL_NV_gpu_program4"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMENVPARAMETERI4UIVNVPROC_HPP)(GLenum target,GLuint index,const GLuint *params);

static inline void ProgramEnvParameterI4uivNV(GLenum target,GLuint index,const GLuint *params)
{
	static PFNPROGRAMENVPARAMETERI4UIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERI4UIVNVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParameterI4uivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNPROGRAMENVPARAMETERSI4UIVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLuint *params);

static inline void ProgramEnvParametersI4uivNV(GLenum target,GLuint index,GLsizei count,const GLuint *params)
{
	static PFNPROGRAMENVPARAMETERSI4UIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMENVPARAMETERSI4UIVNVPROC_HPP>(_impl::_get_proc_address("glProgramEnvParametersI4uivNV","GL_NV_gpu_program4"));
	 fn(target,index,count,params);
}

typedef void (*PFNGETPROGRAMLOCALPARAMETERIIVNVPROC_HPP)(GLenum target,GLuint index,GLint *params);

static inline void GetProgramLocalParameterIivNV(GLenum target,GLuint index,GLint *params)
{
	static PFNGETPROGRAMLOCALPARAMETERIIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMLOCALPARAMETERIIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramLocalParameterIivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMLOCALPARAMETERIUIVNVPROC_HPP)(GLenum target,GLuint index,GLuint *params);

static inline void GetProgramLocalParameterIuivNV(GLenum target,GLuint index,GLuint *params)
{
	static PFNGETPROGRAMLOCALPARAMETERIUIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMLOCALPARAMETERIUIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramLocalParameterIuivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMENVPARAMETERIIVNVPROC_HPP)(GLenum target,GLuint index,GLint *params);

static inline void GetProgramEnvParameterIivNV(GLenum target,GLuint index,GLint *params)
{
	static PFNGETPROGRAMENVPARAMETERIIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMENVPARAMETERIIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramEnvParameterIivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}

typedef void (*PFNGETPROGRAMENVPARAMETERIUIVNVPROC_HPP)(GLenum target,GLuint index,GLuint *params);

static inline void GetProgramEnvParameterIuivNV(GLenum target,GLuint index,GLuint *params)
{
	static PFNGETPROGRAMENVPARAMETERIUIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMENVPARAMETERIUIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramEnvParameterIuivNV","GL_NV_gpu_program4"));
	 fn(target,index,params);
}
#ifndef GL_NV_gpu_program5

#define GL_NV_gpu_program5
#ifndef GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV
#define GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV                          0x8E5A
#endif //GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV
#ifndef GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV
#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV                         0x8E5B
#endif //GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV
#ifndef GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV
#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV                         0x8E5C
#endif //GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV
#ifndef GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV
#define GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV                0x8E5D
#endif //GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV
#ifndef GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV
#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV                         0x8E5E
#endif //GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV
#ifndef GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV
#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV                         0x8E5F
#endif //GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV
#ifndef GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV
#define GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV                         0x8F44
#endif //GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV
#ifndef GL_MAX_PROGRAM_SUBROUTINE_NUM_NV
#define GL_MAX_PROGRAM_SUBROUTINE_NUM_NV                                0x8F45
#endif //GL_MAX_PROGRAM_SUBROUTINE_NUM_NV

#endif //GL_NV_gpu_program5


typedef void (*PFNPROGRAMSUBROUTINEPARAMETERSUIVNVPROC_HPP)(GLenum target,GLsizei count,const GLuint *params);

static inline void ProgramSubroutineParametersuivNV(GLenum target,GLsizei count,const GLuint *params)
{
	static PFNPROGRAMSUBROUTINEPARAMETERSUIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMSUBROUTINEPARAMETERSUIVNVPROC_HPP>(_impl::_get_proc_address("glProgramSubroutineParametersuivNV","GL_NV_gpu_program5"));
	 fn(target,count,params);
}

typedef void (*PFNGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC_HPP)(GLenum target,GLuint index,GLuint *param);

static inline void GetProgramSubroutineParameteruivNV(GLenum target,GLuint index,GLuint *param)
{
	static PFNGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMSUBROUTINEPARAMETERUIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramSubroutineParameteruivNV","GL_NV_gpu_program5"));
	 fn(target,index,param);
}
#ifndef GL_NV_gpu_shader5

#define GL_NV_gpu_shader5
#ifndef GL_INT64_NV
#define GL_INT64_NV                                                     0x140E
#endif //GL_INT64_NV
#ifndef GL_UNSIGNED_INT64_NV
#define GL_UNSIGNED_INT64_NV                                            0x140F
#endif //GL_UNSIGNED_INT64_NV
#ifndef GL_INT8_NV
#define GL_INT8_NV                                                      0x8FE0
#endif //GL_INT8_NV
#ifndef GL_INT8_VEC2_NV
#define GL_INT8_VEC2_NV                                                 0x8FE1
#endif //GL_INT8_VEC2_NV
#ifndef GL_INT8_VEC3_NV
#define GL_INT8_VEC3_NV                                                 0x8FE2
#endif //GL_INT8_VEC3_NV
#ifndef GL_INT8_VEC4_NV
#define GL_INT8_VEC4_NV                                                 0x8FE3
#endif //GL_INT8_VEC4_NV
#ifndef GL_INT16_NV
#define GL_INT16_NV                                                     0x8FE4
#endif //GL_INT16_NV
#ifndef GL_INT16_VEC2_NV
#define GL_INT16_VEC2_NV                                                0x8FE5
#endif //GL_INT16_VEC2_NV
#ifndef GL_INT16_VEC3_NV
#define GL_INT16_VEC3_NV                                                0x8FE6
#endif //GL_INT16_VEC3_NV
#ifndef GL_INT16_VEC4_NV
#define GL_INT16_VEC4_NV                                                0x8FE7
#endif //GL_INT16_VEC4_NV
#ifndef GL_INT64_VEC2_NV
#define GL_INT64_VEC2_NV                                                0x8FE9
#endif //GL_INT64_VEC2_NV
#ifndef GL_INT64_VEC3_NV
#define GL_INT64_VEC3_NV                                                0x8FEA
#endif //GL_INT64_VEC3_NV
#ifndef GL_INT64_VEC4_NV
#define GL_INT64_VEC4_NV                                                0x8FEB
#endif //GL_INT64_VEC4_NV
#ifndef GL_UNSIGNED_INT8_NV
#define GL_UNSIGNED_INT8_NV                                             0x8FEC
#endif //GL_UNSIGNED_INT8_NV
#ifndef GL_UNSIGNED_INT8_VEC2_NV
#define GL_UNSIGNED_INT8_VEC2_NV                                        0x8FED
#endif //GL_UNSIGNED_INT8_VEC2_NV
#ifndef GL_UNSIGNED_INT8_VEC3_NV
#define GL_UNSIGNED_INT8_VEC3_NV                                        0x8FEE
#endif //GL_UNSIGNED_INT8_VEC3_NV
#ifndef GL_UNSIGNED_INT8_VEC4_NV
#define GL_UNSIGNED_INT8_VEC4_NV                                        0x8FEF
#endif //GL_UNSIGNED_INT8_VEC4_NV
#ifndef GL_UNSIGNED_INT16_NV
#define GL_UNSIGNED_INT16_NV                                            0x8FF0
#endif //GL_UNSIGNED_INT16_NV
#ifndef GL_UNSIGNED_INT16_VEC2_NV
#define GL_UNSIGNED_INT16_VEC2_NV                                       0x8FF1
#endif //GL_UNSIGNED_INT16_VEC2_NV
#ifndef GL_UNSIGNED_INT16_VEC3_NV
#define GL_UNSIGNED_INT16_VEC3_NV                                       0x8FF2
#endif //GL_UNSIGNED_INT16_VEC3_NV
#ifndef GL_UNSIGNED_INT16_VEC4_NV
#define GL_UNSIGNED_INT16_VEC4_NV                                       0x8FF3
#endif //GL_UNSIGNED_INT16_VEC4_NV
#ifndef GL_UNSIGNED_INT64_VEC2_NV
#define GL_UNSIGNED_INT64_VEC2_NV                                       0x8FF5
#endif //GL_UNSIGNED_INT64_VEC2_NV
#ifndef GL_UNSIGNED_INT64_VEC3_NV
#define GL_UNSIGNED_INT64_VEC3_NV                                       0x8FF6
#endif //GL_UNSIGNED_INT64_VEC3_NV
#ifndef GL_UNSIGNED_INT64_VEC4_NV
#define GL_UNSIGNED_INT64_VEC4_NV                                       0x8FF7
#endif //GL_UNSIGNED_INT64_VEC4_NV
#ifndef GL_FLOAT16_NV
#define GL_FLOAT16_NV                                                   0x8FF8
#endif //GL_FLOAT16_NV
#ifndef GL_FLOAT16_VEC2_NV
#define GL_FLOAT16_VEC2_NV                                              0x8FF9
#endif //GL_FLOAT16_VEC2_NV
#ifndef GL_FLOAT16_VEC3_NV
#define GL_FLOAT16_VEC3_NV                                              0x8FFA
#endif //GL_FLOAT16_VEC3_NV
#ifndef GL_FLOAT16_VEC4_NV
#define GL_FLOAT16_VEC4_NV                                              0x8FFB
#endif //GL_FLOAT16_VEC4_NV

#endif //GL_NV_gpu_shader5


typedef void (*PFNUNIFORM1I64NVPROC_HPP)(GLint location,GLint64EXT x);

static inline void Uniform1i64NV(GLint location,GLint64EXT x)
{
	static PFNUNIFORM1I64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1I64NVPROC_HPP>(_impl::_get_proc_address("glUniform1i64NV","GL_NV_gpu_shader5"));
	 fn(location,x);
}

typedef void (*PFNUNIFORM2I64NVPROC_HPP)(GLint location,GLint64EXT x,GLint64EXT y);

static inline void Uniform2i64NV(GLint location,GLint64EXT x,GLint64EXT y)
{
	static PFNUNIFORM2I64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2I64NVPROC_HPP>(_impl::_get_proc_address("glUniform2i64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y);
}

typedef void (*PFNUNIFORM3I64NVPROC_HPP)(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z);

static inline void Uniform3i64NV(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z)
{
	static PFNUNIFORM3I64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3I64NVPROC_HPP>(_impl::_get_proc_address("glUniform3i64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y,z);
}

typedef void (*PFNUNIFORM4I64NVPROC_HPP)(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);

static inline void Uniform4i64NV(GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w)
{
	static PFNUNIFORM4I64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4I64NVPROC_HPP>(_impl::_get_proc_address("glUniform4i64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y,z,w);
}

typedef void (*PFNUNIFORM1I64VNVPROC_HPP)(GLint location,GLsizei count,const GLint64EXT *value);

static inline void Uniform1i64vNV(GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNUNIFORM1I64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1I64VNVPROC_HPP>(_impl::_get_proc_address("glUniform1i64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2I64VNVPROC_HPP)(GLint location,GLsizei count,const GLint64EXT *value);

static inline void Uniform2i64vNV(GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNUNIFORM2I64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2I64VNVPROC_HPP>(_impl::_get_proc_address("glUniform2i64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3I64VNVPROC_HPP)(GLint location,GLsizei count,const GLint64EXT *value);

static inline void Uniform3i64vNV(GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNUNIFORM3I64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3I64VNVPROC_HPP>(_impl::_get_proc_address("glUniform3i64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4I64VNVPROC_HPP)(GLint location,GLsizei count,const GLint64EXT *value);

static inline void Uniform4i64vNV(GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNUNIFORM4I64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4I64VNVPROC_HPP>(_impl::_get_proc_address("glUniform4i64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM1UI64NVPROC_HPP)(GLint location,GLuint64EXT x);

static inline void Uniform1ui64NV(GLint location,GLuint64EXT x)
{
	static PFNUNIFORM1UI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UI64NVPROC_HPP>(_impl::_get_proc_address("glUniform1ui64NV","GL_NV_gpu_shader5"));
	 fn(location,x);
}

typedef void (*PFNUNIFORM2UI64NVPROC_HPP)(GLint location,GLuint64EXT x,GLuint64EXT y);

static inline void Uniform2ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y)
{
	static PFNUNIFORM2UI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UI64NVPROC_HPP>(_impl::_get_proc_address("glUniform2ui64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y);
}

typedef void (*PFNUNIFORM3UI64NVPROC_HPP)(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);

static inline void Uniform3ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z)
{
	static PFNUNIFORM3UI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UI64NVPROC_HPP>(_impl::_get_proc_address("glUniform3ui64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y,z);
}

typedef void (*PFNUNIFORM4UI64NVPROC_HPP)(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);

static inline void Uniform4ui64NV(GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w)
{
	static PFNUNIFORM4UI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UI64NVPROC_HPP>(_impl::_get_proc_address("glUniform4ui64NV","GL_NV_gpu_shader5"));
	 fn(location,x,y,z,w);
}

typedef void (*PFNUNIFORM1UI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64EXT *value);

static inline void Uniform1ui64vNV(GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNUNIFORM1UI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM1UI64VNVPROC_HPP>(_impl::_get_proc_address("glUniform1ui64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM2UI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64EXT *value);

static inline void Uniform2ui64vNV(GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNUNIFORM2UI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM2UI64VNVPROC_HPP>(_impl::_get_proc_address("glUniform2ui64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM3UI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64EXT *value);

static inline void Uniform3ui64vNV(GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNUNIFORM3UI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM3UI64VNVPROC_HPP>(_impl::_get_proc_address("glUniform3ui64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNUNIFORM4UI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64EXT *value);

static inline void Uniform4ui64vNV(GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNUNIFORM4UI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORM4UI64VNVPROC_HPP>(_impl::_get_proc_address("glUniform4ui64vNV","GL_NV_gpu_shader5"));
	 fn(location,count,value);
}

typedef void (*PFNGETUNIFORMI64VNVPROC_HPP)(GLuint program,GLint location,GLint64EXT *params);

static inline void GetUniformi64vNV(GLuint program,GLint location,GLint64EXT *params)
{
	static PFNGETUNIFORMI64VNVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMI64VNVPROC_HPP>(_impl::_get_proc_address("glGetUniformi64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,params);
}

typedef void (*PFNPROGRAMUNIFORM1I64NVPROC_HPP)(GLuint program,GLint location,GLint64EXT x);

static inline void ProgramUniform1i64NV(GLuint program,GLint location,GLint64EXT x)
{
	static PFNPROGRAMUNIFORM1I64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1I64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1i64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x);
}

typedef void (*PFNPROGRAMUNIFORM2I64NVPROC_HPP)(GLuint program,GLint location,GLint64EXT x,GLint64EXT y);

static inline void ProgramUniform2i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y)
{
	static PFNPROGRAMUNIFORM2I64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2I64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2i64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y);
}

typedef void (*PFNPROGRAMUNIFORM3I64NVPROC_HPP)(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z);

static inline void ProgramUniform3i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z)
{
	static PFNPROGRAMUNIFORM3I64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3I64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3i64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y,z);
}

typedef void (*PFNPROGRAMUNIFORM4I64NVPROC_HPP)(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);

static inline void ProgramUniform4i64NV(GLuint program,GLint location,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w)
{
	static PFNPROGRAMUNIFORM4I64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4I64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4i64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y,z,w);
}

typedef void (*PFNPROGRAMUNIFORM1I64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint64EXT *value);

static inline void ProgramUniform1i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNPROGRAMUNIFORM1I64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1I64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1i64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2I64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint64EXT *value);

static inline void ProgramUniform2i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNPROGRAMUNIFORM2I64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2I64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2i64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3I64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint64EXT *value);

static inline void ProgramUniform3i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNPROGRAMUNIFORM3I64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3I64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3i64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4I64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLint64EXT *value);

static inline void ProgramUniform4i64vNV(GLuint program,GLint location,GLsizei count,const GLint64EXT *value)
{
	static PFNPROGRAMUNIFORM4I64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4I64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4i64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM1UI64NVPROC_HPP)(GLuint program,GLint location,GLuint64EXT x);

static inline void ProgramUniform1ui64NV(GLuint program,GLint location,GLuint64EXT x)
{
	static PFNPROGRAMUNIFORM1UI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1ui64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x);
}

typedef void (*PFNPROGRAMUNIFORM2UI64NVPROC_HPP)(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y);

static inline void ProgramUniform2ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y)
{
	static PFNPROGRAMUNIFORM2UI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2ui64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y);
}

typedef void (*PFNPROGRAMUNIFORM3UI64NVPROC_HPP)(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);

static inline void ProgramUniform3ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z)
{
	static PFNPROGRAMUNIFORM3UI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3ui64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y,z);
}

typedef void (*PFNPROGRAMUNIFORM4UI64NVPROC_HPP)(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);

static inline void ProgramUniform4ui64NV(GLuint program,GLint location,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w)
{
	static PFNPROGRAMUNIFORM4UI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4ui64NV","GL_NV_gpu_shader5"));
	 fn(program,location,x,y,z,w);
}

typedef void (*PFNPROGRAMUNIFORM1UI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value);

static inline void ProgramUniform1ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNPROGRAMUNIFORM1UI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM1UI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform1ui64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM2UI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value);

static inline void ProgramUniform2ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNPROGRAMUNIFORM2UI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM2UI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform2ui64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM3UI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value);

static inline void ProgramUniform3ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNPROGRAMUNIFORM3UI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM3UI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform3ui64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}

typedef void (*PFNPROGRAMUNIFORM4UI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value);

static inline void ProgramUniform4ui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNPROGRAMUNIFORM4UI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORM4UI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniform4ui64vNV","GL_NV_gpu_shader5"));
	 fn(program,location,count,value);
}
#ifndef GL_NV_half_float

#define GL_NV_half_float
#ifndef GL_HALF_FLOAT_NV
#define GL_HALF_FLOAT_NV                                                0x140B
#endif //GL_HALF_FLOAT_NV

#endif //GL_NV_half_float


typedef void (*PFNVERTEX2HNVPROC_HPP)(GLhalfNV x,GLhalfNV y);

static inline void Vertex2hNV(GLhalfNV x,GLhalfNV y)
{
	static PFNVERTEX2HNVPROC_HPP fn=reinterpret_cast<PFNVERTEX2HNVPROC_HPP>(_impl::_get_proc_address("glVertex2hNV","GL_NV_half_float"));
	 fn(x,y);
}

typedef void (*PFNVERTEX2HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Vertex2hvNV(const GLhalfNV *v)
{
	static PFNVERTEX2HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEX2HVNVPROC_HPP>(_impl::_get_proc_address("glVertex2hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNVERTEX3HNVPROC_HPP)(GLhalfNV x,GLhalfNV y,GLhalfNV z);

static inline void Vertex3hNV(GLhalfNV x,GLhalfNV y,GLhalfNV z)
{
	static PFNVERTEX3HNVPROC_HPP fn=reinterpret_cast<PFNVERTEX3HNVPROC_HPP>(_impl::_get_proc_address("glVertex3hNV","GL_NV_half_float"));
	 fn(x,y,z);
}

typedef void (*PFNVERTEX3HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Vertex3hvNV(const GLhalfNV *v)
{
	static PFNVERTEX3HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEX3HVNVPROC_HPP>(_impl::_get_proc_address("glVertex3hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNVERTEX4HNVPROC_HPP)(GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w);

static inline void Vertex4hNV(GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w)
{
	static PFNVERTEX4HNVPROC_HPP fn=reinterpret_cast<PFNVERTEX4HNVPROC_HPP>(_impl::_get_proc_address("glVertex4hNV","GL_NV_half_float"));
	 fn(x,y,z,w);
}

typedef void (*PFNVERTEX4HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Vertex4hvNV(const GLhalfNV *v)
{
	static PFNVERTEX4HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEX4HVNVPROC_HPP>(_impl::_get_proc_address("glVertex4hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNNORMAL3HNVPROC_HPP)(GLhalfNV nx,GLhalfNV ny,GLhalfNV nz);

static inline void Normal3hNV(GLhalfNV nx,GLhalfNV ny,GLhalfNV nz)
{
	static PFNNORMAL3HNVPROC_HPP fn=reinterpret_cast<PFNNORMAL3HNVPROC_HPP>(_impl::_get_proc_address("glNormal3hNV","GL_NV_half_float"));
	 fn(nx,ny,nz);
}

typedef void (*PFNNORMAL3HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Normal3hvNV(const GLhalfNV *v)
{
	static PFNNORMAL3HVNVPROC_HPP fn=reinterpret_cast<PFNNORMAL3HVNVPROC_HPP>(_impl::_get_proc_address("glNormal3hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNCOLOR3HNVPROC_HPP)(GLhalfNV red,GLhalfNV green,GLhalfNV blue);

static inline void Color3hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue)
{
	static PFNCOLOR3HNVPROC_HPP fn=reinterpret_cast<PFNCOLOR3HNVPROC_HPP>(_impl::_get_proc_address("glColor3hNV","GL_NV_half_float"));
	 fn(red,green,blue);
}

typedef void (*PFNCOLOR3HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Color3hvNV(const GLhalfNV *v)
{
	static PFNCOLOR3HVNVPROC_HPP fn=reinterpret_cast<PFNCOLOR3HVNVPROC_HPP>(_impl::_get_proc_address("glColor3hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNCOLOR4HNVPROC_HPP)(GLhalfNV red,GLhalfNV green,GLhalfNV blue,GLhalfNV alpha);

static inline void Color4hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue,GLhalfNV alpha)
{
	static PFNCOLOR4HNVPROC_HPP fn=reinterpret_cast<PFNCOLOR4HNVPROC_HPP>(_impl::_get_proc_address("glColor4hNV","GL_NV_half_float"));
	 fn(red,green,blue,alpha);
}

typedef void (*PFNCOLOR4HVNVPROC_HPP)(const GLhalfNV *v);

static inline void Color4hvNV(const GLhalfNV *v)
{
	static PFNCOLOR4HVNVPROC_HPP fn=reinterpret_cast<PFNCOLOR4HVNVPROC_HPP>(_impl::_get_proc_address("glColor4hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNTEXCOORD1HNVPROC_HPP)(GLhalfNV s);

static inline void TexCoord1hNV(GLhalfNV s)
{
	static PFNTEXCOORD1HNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD1HNVPROC_HPP>(_impl::_get_proc_address("glTexCoord1hNV","GL_NV_half_float"));
	 fn(s);
}

typedef void (*PFNTEXCOORD1HVNVPROC_HPP)(const GLhalfNV *v);

static inline void TexCoord1hvNV(const GLhalfNV *v)
{
	static PFNTEXCOORD1HVNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD1HVNVPROC_HPP>(_impl::_get_proc_address("glTexCoord1hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNTEXCOORD2HNVPROC_HPP)(GLhalfNV s,GLhalfNV t);

static inline void TexCoord2hNV(GLhalfNV s,GLhalfNV t)
{
	static PFNTEXCOORD2HNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2HNVPROC_HPP>(_impl::_get_proc_address("glTexCoord2hNV","GL_NV_half_float"));
	 fn(s,t);
}

typedef void (*PFNTEXCOORD2HVNVPROC_HPP)(const GLhalfNV *v);

static inline void TexCoord2hvNV(const GLhalfNV *v)
{
	static PFNTEXCOORD2HVNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2HVNVPROC_HPP>(_impl::_get_proc_address("glTexCoord2hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNTEXCOORD3HNVPROC_HPP)(GLhalfNV s,GLhalfNV t,GLhalfNV r);

static inline void TexCoord3hNV(GLhalfNV s,GLhalfNV t,GLhalfNV r)
{
	static PFNTEXCOORD3HNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD3HNVPROC_HPP>(_impl::_get_proc_address("glTexCoord3hNV","GL_NV_half_float"));
	 fn(s,t,r);
}

typedef void (*PFNTEXCOORD3HVNVPROC_HPP)(const GLhalfNV *v);

static inline void TexCoord3hvNV(const GLhalfNV *v)
{
	static PFNTEXCOORD3HVNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD3HVNVPROC_HPP>(_impl::_get_proc_address("glTexCoord3hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNTEXCOORD4HNVPROC_HPP)(GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q);

static inline void TexCoord4hNV(GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q)
{
	static PFNTEXCOORD4HNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4HNVPROC_HPP>(_impl::_get_proc_address("glTexCoord4hNV","GL_NV_half_float"));
	 fn(s,t,r,q);
}

typedef void (*PFNTEXCOORD4HVNVPROC_HPP)(const GLhalfNV *v);

static inline void TexCoord4hvNV(const GLhalfNV *v)
{
	static PFNTEXCOORD4HVNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4HVNVPROC_HPP>(_impl::_get_proc_address("glTexCoord4hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNMULTITEXCOORD1HNVPROC_HPP)(GLenum target,GLhalfNV s);

static inline void MultiTexCoord1hNV(GLenum target,GLhalfNV s)
{
	static PFNMULTITEXCOORD1HNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1HNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1hNV","GL_NV_half_float"));
	 fn(target,s);
}

typedef void (*PFNMULTITEXCOORD1HVNVPROC_HPP)(GLenum target,const GLhalfNV *v);

static inline void MultiTexCoord1hvNV(GLenum target,const GLhalfNV *v)
{
	static PFNMULTITEXCOORD1HVNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD1HVNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord1hvNV","GL_NV_half_float"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD2HNVPROC_HPP)(GLenum target,GLhalfNV s,GLhalfNV t);

static inline void MultiTexCoord2hNV(GLenum target,GLhalfNV s,GLhalfNV t)
{
	static PFNMULTITEXCOORD2HNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2HNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2hNV","GL_NV_half_float"));
	 fn(target,s,t);
}

typedef void (*PFNMULTITEXCOORD2HVNVPROC_HPP)(GLenum target,const GLhalfNV *v);

static inline void MultiTexCoord2hvNV(GLenum target,const GLhalfNV *v)
{
	static PFNMULTITEXCOORD2HVNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD2HVNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord2hvNV","GL_NV_half_float"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD3HNVPROC_HPP)(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r);

static inline void MultiTexCoord3hNV(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r)
{
	static PFNMULTITEXCOORD3HNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3HNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3hNV","GL_NV_half_float"));
	 fn(target,s,t,r);
}

typedef void (*PFNMULTITEXCOORD3HVNVPROC_HPP)(GLenum target,const GLhalfNV *v);

static inline void MultiTexCoord3hvNV(GLenum target,const GLhalfNV *v)
{
	static PFNMULTITEXCOORD3HVNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD3HVNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord3hvNV","GL_NV_half_float"));
	 fn(target,v);
}

typedef void (*PFNMULTITEXCOORD4HNVPROC_HPP)(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q);

static inline void MultiTexCoord4hNV(GLenum target,GLhalfNV s,GLhalfNV t,GLhalfNV r,GLhalfNV q)
{
	static PFNMULTITEXCOORD4HNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4HNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4hNV","GL_NV_half_float"));
	 fn(target,s,t,r,q);
}

typedef void (*PFNMULTITEXCOORD4HVNVPROC_HPP)(GLenum target,const GLhalfNV *v);

static inline void MultiTexCoord4hvNV(GLenum target,const GLhalfNV *v)
{
	static PFNMULTITEXCOORD4HVNVPROC_HPP fn=reinterpret_cast<PFNMULTITEXCOORD4HVNVPROC_HPP>(_impl::_get_proc_address("glMultiTexCoord4hvNV","GL_NV_half_float"));
	 fn(target,v);
}

typedef void (*PFNFOGCOORDHNVPROC_HPP)(GLhalfNV fog);

static inline void FogCoordhNV(GLhalfNV fog)
{
	static PFNFOGCOORDHNVPROC_HPP fn=reinterpret_cast<PFNFOGCOORDHNVPROC_HPP>(_impl::_get_proc_address("glFogCoordhNV","GL_NV_half_float"));
	 fn(fog);
}

typedef void (*PFNFOGCOORDHVNVPROC_HPP)(const GLhalfNV *fog);

static inline void FogCoordhvNV(const GLhalfNV *fog)
{
	static PFNFOGCOORDHVNVPROC_HPP fn=reinterpret_cast<PFNFOGCOORDHVNVPROC_HPP>(_impl::_get_proc_address("glFogCoordhvNV","GL_NV_half_float"));
	 fn(fog);
}

typedef void (*PFNSECONDARYCOLOR3HNVPROC_HPP)(GLhalfNV red,GLhalfNV green,GLhalfNV blue);

static inline void SecondaryColor3hNV(GLhalfNV red,GLhalfNV green,GLhalfNV blue)
{
	static PFNSECONDARYCOLOR3HNVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3HNVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3hNV","GL_NV_half_float"));
	 fn(red,green,blue);
}

typedef void (*PFNSECONDARYCOLOR3HVNVPROC_HPP)(const GLhalfNV *v);

static inline void SecondaryColor3hvNV(const GLhalfNV *v)
{
	static PFNSECONDARYCOLOR3HVNVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLOR3HVNVPROC_HPP>(_impl::_get_proc_address("glSecondaryColor3hvNV","GL_NV_half_float"));
	 fn(v);
}

typedef void (*PFNVERTEXWEIGHTHNVPROC_HPP)(GLhalfNV weight);

static inline void VertexWeighthNV(GLhalfNV weight)
{
	static PFNVERTEXWEIGHTHNVPROC_HPP fn=reinterpret_cast<PFNVERTEXWEIGHTHNVPROC_HPP>(_impl::_get_proc_address("glVertexWeighthNV","GL_NV_half_float"));
	 fn(weight);
}

typedef void (*PFNVERTEXWEIGHTHVNVPROC_HPP)(const GLhalfNV *weight);

static inline void VertexWeighthvNV(const GLhalfNV *weight)
{
	static PFNVERTEXWEIGHTHVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXWEIGHTHVNVPROC_HPP>(_impl::_get_proc_address("glVertexWeighthvNV","GL_NV_half_float"));
	 fn(weight);
}

typedef void (*PFNVERTEXATTRIB1HNVPROC_HPP)(GLuint index,GLhalfNV x);

static inline void VertexAttrib1hNV(GLuint index,GLhalfNV x)
{
	static PFNVERTEXATTRIB1HNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1HNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1hNV","GL_NV_half_float"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1HVNVPROC_HPP)(GLuint index,const GLhalfNV *v);

static inline void VertexAttrib1hvNV(GLuint index,const GLhalfNV *v)
{
	static PFNVERTEXATTRIB1HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1hvNV","GL_NV_half_float"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2HNVPROC_HPP)(GLuint index,GLhalfNV x,GLhalfNV y);

static inline void VertexAttrib2hNV(GLuint index,GLhalfNV x,GLhalfNV y)
{
	static PFNVERTEXATTRIB2HNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2HNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2hNV","GL_NV_half_float"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2HVNVPROC_HPP)(GLuint index,const GLhalfNV *v);

static inline void VertexAttrib2hvNV(GLuint index,const GLhalfNV *v)
{
	static PFNVERTEXATTRIB2HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2hvNV","GL_NV_half_float"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3HNVPROC_HPP)(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z);

static inline void VertexAttrib3hNV(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z)
{
	static PFNVERTEXATTRIB3HNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3HNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3hNV","GL_NV_half_float"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3HVNVPROC_HPP)(GLuint index,const GLhalfNV *v);

static inline void VertexAttrib3hvNV(GLuint index,const GLhalfNV *v)
{
	static PFNVERTEXATTRIB3HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3hvNV","GL_NV_half_float"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4HNVPROC_HPP)(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w);

static inline void VertexAttrib4hNV(GLuint index,GLhalfNV x,GLhalfNV y,GLhalfNV z,GLhalfNV w)
{
	static PFNVERTEXATTRIB4HNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4HNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4hNV","GL_NV_half_float"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4HVNVPROC_HPP)(GLuint index,const GLhalfNV *v);

static inline void VertexAttrib4hvNV(GLuint index,const GLhalfNV *v)
{
	static PFNVERTEXATTRIB4HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4hvNV","GL_NV_half_float"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBS1HVNVPROC_HPP)(GLuint index,GLsizei n,const GLhalfNV *v);

static inline void VertexAttribs1hvNV(GLuint index,GLsizei n,const GLhalfNV *v)
{
	static PFNVERTEXATTRIBS1HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS1HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs1hvNV","GL_NV_half_float"));
	 fn(index,n,v);
}

typedef void (*PFNVERTEXATTRIBS2HVNVPROC_HPP)(GLuint index,GLsizei n,const GLhalfNV *v);

static inline void VertexAttribs2hvNV(GLuint index,GLsizei n,const GLhalfNV *v)
{
	static PFNVERTEXATTRIBS2HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS2HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs2hvNV","GL_NV_half_float"));
	 fn(index,n,v);
}

typedef void (*PFNVERTEXATTRIBS3HVNVPROC_HPP)(GLuint index,GLsizei n,const GLhalfNV *v);

static inline void VertexAttribs3hvNV(GLuint index,GLsizei n,const GLhalfNV *v)
{
	static PFNVERTEXATTRIBS3HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS3HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs3hvNV","GL_NV_half_float"));
	 fn(index,n,v);
}

typedef void (*PFNVERTEXATTRIBS4HVNVPROC_HPP)(GLuint index,GLsizei n,const GLhalfNV *v);

static inline void VertexAttribs4hvNV(GLuint index,GLsizei n,const GLhalfNV *v)
{
	static PFNVERTEXATTRIBS4HVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS4HVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs4hvNV","GL_NV_half_float"));
	 fn(index,n,v);
}
#ifndef GL_NV_light_max_exponent

#define GL_NV_light_max_exponent
#ifndef GL_MAX_SHININESS_NV
#define GL_MAX_SHININESS_NV                                             0x8504
#endif //GL_MAX_SHININESS_NV
#ifndef GL_MAX_SPOT_EXPONENT_NV
#define GL_MAX_SPOT_EXPONENT_NV                                         0x8505
#endif //GL_MAX_SPOT_EXPONENT_NV

#endif //GL_NV_light_max_exponent

#ifndef GL_NV_multisample_coverage

#define GL_NV_multisample_coverage
#ifndef GL_COLOR_SAMPLES_NV
#define GL_COLOR_SAMPLES_NV                                             0x8E20
#endif //GL_COLOR_SAMPLES_NV

#endif //GL_NV_multisample_coverage

#ifndef GL_NV_occlusion_query

#define GL_NV_occlusion_query
#ifndef GL_PIXEL_COUNTER_BITS_NV
#define GL_PIXEL_COUNTER_BITS_NV                                        0x8864
#endif //GL_PIXEL_COUNTER_BITS_NV
#ifndef GL_CURRENT_OCCLUSION_QUERY_ID_NV
#define GL_CURRENT_OCCLUSION_QUERY_ID_NV                                0x8865
#endif //GL_CURRENT_OCCLUSION_QUERY_ID_NV
#ifndef GL_PIXEL_COUNT_NV
#define GL_PIXEL_COUNT_NV                                               0x8866
#endif //GL_PIXEL_COUNT_NV
#ifndef GL_PIXEL_COUNT_AVAILABLE_NV
#define GL_PIXEL_COUNT_AVAILABLE_NV                                     0x8867
#endif //GL_PIXEL_COUNT_AVAILABLE_NV

#endif //GL_NV_occlusion_query


typedef void (*PFNGENOCCLUSIONQUERIESNVPROC_HPP)(GLsizei n,GLuint *ids);

static inline void GenOcclusionQueriesNV(GLsizei n,GLuint *ids)
{
	static PFNGENOCCLUSIONQUERIESNVPROC_HPP fn=reinterpret_cast<PFNGENOCCLUSIONQUERIESNVPROC_HPP>(_impl::_get_proc_address("glGenOcclusionQueriesNV","GL_NV_occlusion_query"));
	 fn(n,ids);
}

typedef void (*PFNDELETEOCCLUSIONQUERIESNVPROC_HPP)(GLsizei n,const GLuint *ids);

static inline void DeleteOcclusionQueriesNV(GLsizei n,const GLuint *ids)
{
	static PFNDELETEOCCLUSIONQUERIESNVPROC_HPP fn=reinterpret_cast<PFNDELETEOCCLUSIONQUERIESNVPROC_HPP>(_impl::_get_proc_address("glDeleteOcclusionQueriesNV","GL_NV_occlusion_query"));
	 fn(n,ids);
}

typedef GLboolean (*PFNISOCCLUSIONQUERYNVPROC_HPP)(GLuint id);

static inline GLboolean IsOcclusionQueryNV(GLuint id)
{
	static PFNISOCCLUSIONQUERYNVPROC_HPP fn=reinterpret_cast<PFNISOCCLUSIONQUERYNVPROC_HPP>(_impl::_get_proc_address("glIsOcclusionQueryNV","GL_NV_occlusion_query"));
	return fn(id);
}

typedef void (*PFNBEGINOCCLUSIONQUERYNVPROC_HPP)(GLuint id);

static inline void BeginOcclusionQueryNV(GLuint id)
{
	static PFNBEGINOCCLUSIONQUERYNVPROC_HPP fn=reinterpret_cast<PFNBEGINOCCLUSIONQUERYNVPROC_HPP>(_impl::_get_proc_address("glBeginOcclusionQueryNV","GL_NV_occlusion_query"));
	 fn(id);
}

typedef void (*PFNENDOCCLUSIONQUERYNVPROC_HPP)();

static inline void EndOcclusionQueryNV()
{
	static PFNENDOCCLUSIONQUERYNVPROC_HPP fn=reinterpret_cast<PFNENDOCCLUSIONQUERYNVPROC_HPP>(_impl::_get_proc_address("glEndOcclusionQueryNV","GL_NV_occlusion_query"));
	 fn();
}

typedef void (*PFNGETOCCLUSIONQUERYIVNVPROC_HPP)(GLuint id,GLenum pname,GLint *params);

static inline void GetOcclusionQueryivNV(GLuint id,GLenum pname,GLint *params)
{
	static PFNGETOCCLUSIONQUERYIVNVPROC_HPP fn=reinterpret_cast<PFNGETOCCLUSIONQUERYIVNVPROC_HPP>(_impl::_get_proc_address("glGetOcclusionQueryivNV","GL_NV_occlusion_query"));
	 fn(id,pname,params);
}

typedef void (*PFNGETOCCLUSIONQUERYUIVNVPROC_HPP)(GLuint id,GLenum pname,GLuint *params);

static inline void GetOcclusionQueryuivNV(GLuint id,GLenum pname,GLuint *params)
{
	static PFNGETOCCLUSIONQUERYUIVNVPROC_HPP fn=reinterpret_cast<PFNGETOCCLUSIONQUERYUIVNVPROC_HPP>(_impl::_get_proc_address("glGetOcclusionQueryuivNV","GL_NV_occlusion_query"));
	 fn(id,pname,params);
}
#ifndef GL_NV_packed_depth_stencil

#define GL_NV_packed_depth_stencil
#ifndef GL_DEPTH_STENCIL_NV
#define GL_DEPTH_STENCIL_NV                                             0x84F9
#endif //GL_DEPTH_STENCIL_NV
#ifndef GL_UNSIGNED_INT_24_8_NV
#define GL_UNSIGNED_INT_24_8_NV                                         0x84FA
#endif //GL_UNSIGNED_INT_24_8_NV

#endif //GL_NV_packed_depth_stencil

#ifndef GL_NV_parameter_buffer_object

#define GL_NV_parameter_buffer_object
#ifndef GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV
#define GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV                     0x8DA0
#endif //GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV
#ifndef GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV
#define GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV                         0x8DA1
#endif //GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV
#ifndef GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV
#define GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV                           0x8DA2
#endif //GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV
#ifndef GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV
#define GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV                         0x8DA3
#endif //GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV
#ifndef GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV
#define GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV                         0x8DA4
#endif //GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV

#endif //GL_NV_parameter_buffer_object


typedef void (*PFNPROGRAMBUFFERPARAMETERSFVNVPROC_HPP)(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLfloat *params);

static inline void ProgramBufferParametersfvNV(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLfloat *params)
{
	static PFNPROGRAMBUFFERPARAMETERSFVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMBUFFERPARAMETERSFVNVPROC_HPP>(_impl::_get_proc_address("glProgramBufferParametersfvNV","GL_NV_parameter_buffer_object"));
	 fn(target,buffer,index,count,params);
}

typedef void (*PFNPROGRAMBUFFERPARAMETERSIIVNVPROC_HPP)(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLint *params);

static inline void ProgramBufferParametersIivNV(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLint *params)
{
	static PFNPROGRAMBUFFERPARAMETERSIIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMBUFFERPARAMETERSIIVNVPROC_HPP>(_impl::_get_proc_address("glProgramBufferParametersIivNV","GL_NV_parameter_buffer_object"));
	 fn(target,buffer,index,count,params);
}

typedef void (*PFNPROGRAMBUFFERPARAMETERSIUIVNVPROC_HPP)(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLuint *params);

static inline void ProgramBufferParametersIuivNV(GLenum target,GLuint buffer,GLuint index,GLsizei count,const GLuint *params)
{
	static PFNPROGRAMBUFFERPARAMETERSIUIVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMBUFFERPARAMETERSIUIVNVPROC_HPP>(_impl::_get_proc_address("glProgramBufferParametersIuivNV","GL_NV_parameter_buffer_object"));
	 fn(target,buffer,index,count,params);
}
#ifndef GL_NV_path_rendering

#define GL_NV_path_rendering
#ifndef GL_CLOSE_PATH_NV
#define GL_CLOSE_PATH_NV                                                0x00
#endif //GL_CLOSE_PATH_NV
#ifndef GL_FONT_X_MIN_BOUNDS_NV
#define GL_FONT_X_MIN_BOUNDS_NV                                         0x00010000
#endif //GL_FONT_X_MIN_BOUNDS_NV
#ifndef GL_FONT_Y_MIN_BOUNDS_NV
#define GL_FONT_Y_MIN_BOUNDS_NV                                         0x00020000
#endif //GL_FONT_Y_MIN_BOUNDS_NV
#ifndef GL_FONT_X_MAX_BOUNDS_NV
#define GL_FONT_X_MAX_BOUNDS_NV                                         0x00040000
#endif //GL_FONT_X_MAX_BOUNDS_NV
#ifndef GL_FONT_Y_MAX_BOUNDS_NV
#define GL_FONT_Y_MAX_BOUNDS_NV                                         0x00080000
#endif //GL_FONT_Y_MAX_BOUNDS_NV
#ifndef GL_FONT_UNITS_PER_EM_NV
#define GL_FONT_UNITS_PER_EM_NV                                         0x00100000
#endif //GL_FONT_UNITS_PER_EM_NV
#ifndef GL_FONT_ASCENDER_NV
#define GL_FONT_ASCENDER_NV                                             0x00200000
#endif //GL_FONT_ASCENDER_NV
#ifndef GL_FONT_DESCENDER_NV
#define GL_FONT_DESCENDER_NV                                            0x00400000
#endif //GL_FONT_DESCENDER_NV
#ifndef GL_FONT_HEIGHT_NV
#define GL_FONT_HEIGHT_NV                                               0x00800000
#endif //GL_FONT_HEIGHT_NV
#ifndef GL_GLYPH_WIDTH_BIT_NV
#define GL_GLYPH_WIDTH_BIT_NV                                           0x01
#endif //GL_GLYPH_WIDTH_BIT_NV
#ifndef GL_BOLD_BIT_NV
#define GL_BOLD_BIT_NV                                                  0x01
#endif //GL_BOLD_BIT_NV
#ifndef GL_FONT_MAX_ADVANCE_WIDTH_NV
#define GL_FONT_MAX_ADVANCE_WIDTH_NV                                    0x01000000
#endif //GL_FONT_MAX_ADVANCE_WIDTH_NV
#ifndef GL_MOVE_TO_NV
#define GL_MOVE_TO_NV                                                   0x02
#endif //GL_MOVE_TO_NV
#ifndef GL_GLYPH_HEIGHT_BIT_NV
#define GL_GLYPH_HEIGHT_BIT_NV                                          0x02
#endif //GL_GLYPH_HEIGHT_BIT_NV
#ifndef GL_ITALIC_BIT_NV
#define GL_ITALIC_BIT_NV                                                0x02
#endif //GL_ITALIC_BIT_NV
#ifndef GL_FONT_MAX_ADVANCE_HEIGHT_NV
#define GL_FONT_MAX_ADVANCE_HEIGHT_NV                                   0x02000000
#endif //GL_FONT_MAX_ADVANCE_HEIGHT_NV
#ifndef GL_RELATIVE_MOVE_TO_NV
#define GL_RELATIVE_MOVE_TO_NV                                          0x03
#endif //GL_RELATIVE_MOVE_TO_NV
#ifndef GL_LINE_TO_NV
#define GL_LINE_TO_NV                                                   0x04
#endif //GL_LINE_TO_NV
#ifndef GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV
#define GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV                            0x04
#endif //GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV
#ifndef GL_FONT_UNDERLINE_POSITION_NV
#define GL_FONT_UNDERLINE_POSITION_NV                                   0x04000000
#endif //GL_FONT_UNDERLINE_POSITION_NV
#ifndef GL_RELATIVE_LINE_TO_NV
#define GL_RELATIVE_LINE_TO_NV                                          0x05
#endif //GL_RELATIVE_LINE_TO_NV
#ifndef GL_HORIZONTAL_LINE_TO_NV
#define GL_HORIZONTAL_LINE_TO_NV                                        0x06
#endif //GL_HORIZONTAL_LINE_TO_NV
#ifndef GL_RELATIVE_HORIZONTAL_LINE_TO_NV
#define GL_RELATIVE_HORIZONTAL_LINE_TO_NV                               0x07
#endif //GL_RELATIVE_HORIZONTAL_LINE_TO_NV
#ifndef GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV
#define GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV                            0x08
#endif //GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV
#ifndef GL_VERTICAL_LINE_TO_NV
#define GL_VERTICAL_LINE_TO_NV                                          0x08
#endif //GL_VERTICAL_LINE_TO_NV
#ifndef GL_FONT_UNDERLINE_THICKNESS_NV
#define GL_FONT_UNDERLINE_THICKNESS_NV                                  0x08000000
#endif //GL_FONT_UNDERLINE_THICKNESS_NV
#ifndef GL_RELATIVE_VERTICAL_LINE_TO_NV
#define GL_RELATIVE_VERTICAL_LINE_TO_NV                                 0x09
#endif //GL_RELATIVE_VERTICAL_LINE_TO_NV
#ifndef GL_QUADRATIC_CURVE_TO_NV
#define GL_QUADRATIC_CURVE_TO_NV                                        0x0A
#endif //GL_QUADRATIC_CURVE_TO_NV
#ifndef GL_RELATIVE_QUADRATIC_CURVE_TO_NV
#define GL_RELATIVE_QUADRATIC_CURVE_TO_NV                               0x0B
#endif //GL_RELATIVE_QUADRATIC_CURVE_TO_NV
#ifndef GL_CUBIC_CURVE_TO_NV
#define GL_CUBIC_CURVE_TO_NV                                            0x0C
#endif //GL_CUBIC_CURVE_TO_NV
#ifndef GL_RELATIVE_CUBIC_CURVE_TO_NV
#define GL_RELATIVE_CUBIC_CURVE_TO_NV                                   0x0D
#endif //GL_RELATIVE_CUBIC_CURVE_TO_NV
#ifndef GL_SMOOTH_QUADRATIC_CURVE_TO_NV
#define GL_SMOOTH_QUADRATIC_CURVE_TO_NV                                 0x0E
#endif //GL_SMOOTH_QUADRATIC_CURVE_TO_NV
#ifndef GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV
#define GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV                        0x0F
#endif //GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV
#ifndef GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV
#define GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV                      0x10
#endif //GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV
#ifndef GL_SMOOTH_CUBIC_CURVE_TO_NV
#define GL_SMOOTH_CUBIC_CURVE_TO_NV                                     0x10
#endif //GL_SMOOTH_CUBIC_CURVE_TO_NV
#ifndef GL_GLYPH_HAS_KERNING_NV
#define GL_GLYPH_HAS_KERNING_NV                                         0x100
#endif //GL_GLYPH_HAS_KERNING_NV
#ifndef GL_FONT_HAS_KERNING_NV
#define GL_FONT_HAS_KERNING_NV                                          0x10000000
#endif //GL_FONT_HAS_KERNING_NV
#ifndef GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV
#define GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV                            0x11
#endif //GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV
#ifndef GL_SMALL_CCW_ARC_TO_NV
#define GL_SMALL_CCW_ARC_TO_NV                                          0x12
#endif //GL_SMALL_CCW_ARC_TO_NV
#ifndef GL_RELATIVE_SMALL_CCW_ARC_TO_NV
#define GL_RELATIVE_SMALL_CCW_ARC_TO_NV                                 0x13
#endif //GL_RELATIVE_SMALL_CCW_ARC_TO_NV
#ifndef GL_SMALL_CW_ARC_TO_NV
#define GL_SMALL_CW_ARC_TO_NV                                           0x14
#endif //GL_SMALL_CW_ARC_TO_NV
#ifndef GL_RELATIVE_SMALL_CW_ARC_TO_NV
#define GL_RELATIVE_SMALL_CW_ARC_TO_NV                                  0x15
#endif //GL_RELATIVE_SMALL_CW_ARC_TO_NV
#ifndef GL_LARGE_CCW_ARC_TO_NV
#define GL_LARGE_CCW_ARC_TO_NV                                          0x16
#endif //GL_LARGE_CCW_ARC_TO_NV
#ifndef GL_RELATIVE_LARGE_CCW_ARC_TO_NV
#define GL_RELATIVE_LARGE_CCW_ARC_TO_NV                                 0x17
#endif //GL_RELATIVE_LARGE_CCW_ARC_TO_NV
#ifndef GL_LARGE_CW_ARC_TO_NV
#define GL_LARGE_CW_ARC_TO_NV                                           0x18
#endif //GL_LARGE_CW_ARC_TO_NV
#ifndef GL_RELATIVE_LARGE_CW_ARC_TO_NV
#define GL_RELATIVE_LARGE_CW_ARC_TO_NV                                  0x19
#endif //GL_RELATIVE_LARGE_CW_ARC_TO_NV
#ifndef GL_GLYPH_VERTICAL_BEARING_X_BIT_NV
#define GL_GLYPH_VERTICAL_BEARING_X_BIT_NV                              0x20
#endif //GL_GLYPH_VERTICAL_BEARING_X_BIT_NV
#ifndef GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV
#define GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV                              0x40
#endif //GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV
#ifndef GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV
#define GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV                        0x80
#endif //GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV
#ifndef GL_PATH_FORMAT_SVG_NV
#define GL_PATH_FORMAT_SVG_NV                                           0x9070
#endif //GL_PATH_FORMAT_SVG_NV
#ifndef GL_PATH_FORMAT_PS_NV
#define GL_PATH_FORMAT_PS_NV                                            0x9071
#endif //GL_PATH_FORMAT_PS_NV
#ifndef GL_STANDARD_FONT_NAME_NV
#define GL_STANDARD_FONT_NAME_NV                                        0x9072
#endif //GL_STANDARD_FONT_NAME_NV
#ifndef GL_SYSTEM_FONT_NAME_NV
#define GL_SYSTEM_FONT_NAME_NV                                          0x9073
#endif //GL_SYSTEM_FONT_NAME_NV
#ifndef GL_FILE_NAME_NV
#define GL_FILE_NAME_NV                                                 0x9074
#endif //GL_FILE_NAME_NV
#ifndef GL_PATH_STROKE_WIDTH_NV
#define GL_PATH_STROKE_WIDTH_NV                                         0x9075
#endif //GL_PATH_STROKE_WIDTH_NV
#ifndef GL_PATH_END_CAPS_NV
#define GL_PATH_END_CAPS_NV                                             0x9076
#endif //GL_PATH_END_CAPS_NV
#ifndef GL_PATH_INITIAL_END_CAP_NV
#define GL_PATH_INITIAL_END_CAP_NV                                      0x9077
#endif //GL_PATH_INITIAL_END_CAP_NV
#ifndef GL_PATH_TERMINAL_END_CAP_NV
#define GL_PATH_TERMINAL_END_CAP_NV                                     0x9078
#endif //GL_PATH_TERMINAL_END_CAP_NV
#ifndef GL_PATH_JOIN_STYLE_NV
#define GL_PATH_JOIN_STYLE_NV                                           0x9079
#endif //GL_PATH_JOIN_STYLE_NV
#ifndef GL_PATH_MITER_LIMIT_NV
#define GL_PATH_MITER_LIMIT_NV                                          0x907A
#endif //GL_PATH_MITER_LIMIT_NV
#ifndef GL_PATH_DASH_CAPS_NV
#define GL_PATH_DASH_CAPS_NV                                            0x907B
#endif //GL_PATH_DASH_CAPS_NV
#ifndef GL_PATH_INITIAL_DASH_CAP_NV
#define GL_PATH_INITIAL_DASH_CAP_NV                                     0x907C
#endif //GL_PATH_INITIAL_DASH_CAP_NV
#ifndef GL_PATH_TERMINAL_DASH_CAP_NV
#define GL_PATH_TERMINAL_DASH_CAP_NV                                    0x907D
#endif //GL_PATH_TERMINAL_DASH_CAP_NV
#ifndef GL_PATH_DASH_OFFSET_NV
#define GL_PATH_DASH_OFFSET_NV                                          0x907E
#endif //GL_PATH_DASH_OFFSET_NV
#ifndef GL_PATH_CLIENT_LENGTH_NV
#define GL_PATH_CLIENT_LENGTH_NV                                        0x907F
#endif //GL_PATH_CLIENT_LENGTH_NV
#ifndef GL_PATH_FILL_MODE_NV
#define GL_PATH_FILL_MODE_NV                                            0x9080
#endif //GL_PATH_FILL_MODE_NV
#ifndef GL_PATH_FILL_MASK_NV
#define GL_PATH_FILL_MASK_NV                                            0x9081
#endif //GL_PATH_FILL_MASK_NV
#ifndef GL_PATH_FILL_COVER_MODE_NV
#define GL_PATH_FILL_COVER_MODE_NV                                      0x9082
#endif //GL_PATH_FILL_COVER_MODE_NV
#ifndef GL_PATH_STROKE_COVER_MODE_NV
#define GL_PATH_STROKE_COVER_MODE_NV                                    0x9083
#endif //GL_PATH_STROKE_COVER_MODE_NV
#ifndef GL_PATH_STROKE_MASK_NV
#define GL_PATH_STROKE_MASK_NV                                          0x9084
#endif //GL_PATH_STROKE_MASK_NV
#ifndef GL_PATH_SAMPLE_QUALITY_NV
#define GL_PATH_SAMPLE_QUALITY_NV                                       0x9085
#endif //GL_PATH_SAMPLE_QUALITY_NV
#ifndef GL_PATH_STROKE_BOUND_NV
#define GL_PATH_STROKE_BOUND_NV                                         0x9086
#endif //GL_PATH_STROKE_BOUND_NV
#ifndef GL_PATH_STROKE_OVERSAMPLE_COUNT_NV
#define GL_PATH_STROKE_OVERSAMPLE_COUNT_NV                              0x9087
#endif //GL_PATH_STROKE_OVERSAMPLE_COUNT_NV
#ifndef GL_COUNT_UP_NV
#define GL_COUNT_UP_NV                                                  0x9088
#endif //GL_COUNT_UP_NV
#ifndef GL_COUNT_DOWN_NV
#define GL_COUNT_DOWN_NV                                                0x9089
#endif //GL_COUNT_DOWN_NV
#ifndef GL_PATH_OBJECT_BOUNDING_BOX_NV
#define GL_PATH_OBJECT_BOUNDING_BOX_NV                                  0x908A
#endif //GL_PATH_OBJECT_BOUNDING_BOX_NV
#ifndef GL_CONVEX_HULL_NV
#define GL_CONVEX_HULL_NV                                               0x908B
#endif //GL_CONVEX_HULL_NV
#ifndef GL_MULTI_HULLS_NV
#define GL_MULTI_HULLS_NV                                               0x908C
#endif //GL_MULTI_HULLS_NV
#ifndef GL_BOUNDING_BOX_NV
#define GL_BOUNDING_BOX_NV                                              0x908D
#endif //GL_BOUNDING_BOX_NV
#ifndef GL_TRANSLATE_X_NV
#define GL_TRANSLATE_X_NV                                               0x908E
#endif //GL_TRANSLATE_X_NV
#ifndef GL_TRANSLATE_Y_NV
#define GL_TRANSLATE_Y_NV                                               0x908F
#endif //GL_TRANSLATE_Y_NV
#ifndef GL_TRANSLATE_2D_NV
#define GL_TRANSLATE_2D_NV                                              0x9090
#endif //GL_TRANSLATE_2D_NV
#ifndef GL_TRANSLATE_3D_NV
#define GL_TRANSLATE_3D_NV                                              0x9091
#endif //GL_TRANSLATE_3D_NV
#ifndef GL_AFFINE_2D_NV
#define GL_AFFINE_2D_NV                                                 0x9092
#endif //GL_AFFINE_2D_NV
#ifndef GL_PROJECTIVE_2D_NV
#define GL_PROJECTIVE_2D_NV                                             0x9093
#endif //GL_PROJECTIVE_2D_NV
#ifndef GL_AFFINE_3D_NV
#define GL_AFFINE_3D_NV                                                 0x9094
#endif //GL_AFFINE_3D_NV
#ifndef GL_PROJECTIVE_3D_NV
#define GL_PROJECTIVE_3D_NV                                             0x9095
#endif //GL_PROJECTIVE_3D_NV
#ifndef GL_TRANSPOSE_AFFINE_2D_NV
#define GL_TRANSPOSE_AFFINE_2D_NV                                       0x9096
#endif //GL_TRANSPOSE_AFFINE_2D_NV
#ifndef GL_TRANSPOSE_PROJECTIVE_2D_NV
#define GL_TRANSPOSE_PROJECTIVE_2D_NV                                   0x9097
#endif //GL_TRANSPOSE_PROJECTIVE_2D_NV
#ifndef GL_TRANSPOSE_AFFINE_3D_NV
#define GL_TRANSPOSE_AFFINE_3D_NV                                       0x9098
#endif //GL_TRANSPOSE_AFFINE_3D_NV
#ifndef GL_TRANSPOSE_PROJECTIVE_3D_NV
#define GL_TRANSPOSE_PROJECTIVE_3D_NV                                   0x9099
#endif //GL_TRANSPOSE_PROJECTIVE_3D_NV
#ifndef GL_UTF8_NV
#define GL_UTF8_NV                                                      0x909A
#endif //GL_UTF8_NV
#ifndef GL_UTF16_NV
#define GL_UTF16_NV                                                     0x909B
#endif //GL_UTF16_NV
#ifndef GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV
#define GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV                            0x909C
#endif //GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV
#ifndef GL_PATH_COMMAND_COUNT_NV
#define GL_PATH_COMMAND_COUNT_NV                                        0x909D
#endif //GL_PATH_COMMAND_COUNT_NV
#ifndef GL_PATH_COORD_COUNT_NV
#define GL_PATH_COORD_COUNT_NV                                          0x909E
#endif //GL_PATH_COORD_COUNT_NV
#ifndef GL_PATH_DASH_ARRAY_COUNT_NV
#define GL_PATH_DASH_ARRAY_COUNT_NV                                     0x909F
#endif //GL_PATH_DASH_ARRAY_COUNT_NV
#ifndef GL_PATH_COMPUTED_LENGTH_NV
#define GL_PATH_COMPUTED_LENGTH_NV                                      0x90A0
#endif //GL_PATH_COMPUTED_LENGTH_NV
#ifndef GL_PATH_FILL_BOUNDING_BOX_NV
#define GL_PATH_FILL_BOUNDING_BOX_NV                                    0x90A1
#endif //GL_PATH_FILL_BOUNDING_BOX_NV
#ifndef GL_PATH_STROKE_BOUNDING_BOX_NV
#define GL_PATH_STROKE_BOUNDING_BOX_NV                                  0x90A2
#endif //GL_PATH_STROKE_BOUNDING_BOX_NV
#ifndef GL_SQUARE_NV
#define GL_SQUARE_NV                                                    0x90A3
#endif //GL_SQUARE_NV
#ifndef GL_ROUND_NV
#define GL_ROUND_NV                                                     0x90A4
#endif //GL_ROUND_NV
#ifndef GL_TRIANGULAR_NV
#define GL_TRIANGULAR_NV                                                0x90A5
#endif //GL_TRIANGULAR_NV
#ifndef GL_BEVEL_NV
#define GL_BEVEL_NV                                                     0x90A6
#endif //GL_BEVEL_NV
#ifndef GL_MITER_REVERT_NV
#define GL_MITER_REVERT_NV                                              0x90A7
#endif //GL_MITER_REVERT_NV
#ifndef GL_MITER_TRUNCATE_NV
#define GL_MITER_TRUNCATE_NV                                            0x90A8
#endif //GL_MITER_TRUNCATE_NV
#ifndef GL_SKIP_MISSING_GLYPH_NV
#define GL_SKIP_MISSING_GLYPH_NV                                        0x90A9
#endif //GL_SKIP_MISSING_GLYPH_NV
#ifndef GL_USE_MISSING_GLYPH_NV
#define GL_USE_MISSING_GLYPH_NV                                         0x90AA
#endif //GL_USE_MISSING_GLYPH_NV
#ifndef GL_PATH_ERROR_POSITION_NV
#define GL_PATH_ERROR_POSITION_NV                                       0x90AB
#endif //GL_PATH_ERROR_POSITION_NV
#ifndef GL_PATH_FOG_GEN_MODE_NV
#define GL_PATH_FOG_GEN_MODE_NV                                         0x90AC
#endif //GL_PATH_FOG_GEN_MODE_NV
#ifndef GL_ACCUM_ADJACENT_PAIRS_NV
#define GL_ACCUM_ADJACENT_PAIRS_NV                                      0x90AD
#endif //GL_ACCUM_ADJACENT_PAIRS_NV
#ifndef GL_ADJACENT_PAIRS_NV
#define GL_ADJACENT_PAIRS_NV                                            0x90AE
#endif //GL_ADJACENT_PAIRS_NV
#ifndef GL_FIRST_TO_REST_NV
#define GL_FIRST_TO_REST_NV                                             0x90AF
#endif //GL_FIRST_TO_REST_NV
#ifndef GL_PATH_GEN_MODE_NV
#define GL_PATH_GEN_MODE_NV                                             0x90B0
#endif //GL_PATH_GEN_MODE_NV
#ifndef GL_PATH_GEN_COEFF_NV
#define GL_PATH_GEN_COEFF_NV                                            0x90B1
#endif //GL_PATH_GEN_COEFF_NV
#ifndef GL_PATH_GEN_COLOR_FORMAT_NV
#define GL_PATH_GEN_COLOR_FORMAT_NV                                     0x90B2
#endif //GL_PATH_GEN_COLOR_FORMAT_NV
#ifndef GL_PATH_GEN_COMPONENTS_NV
#define GL_PATH_GEN_COMPONENTS_NV                                       0x90B3
#endif //GL_PATH_GEN_COMPONENTS_NV
#ifndef GL_PATH_DASH_OFFSET_RESET_NV
#define GL_PATH_DASH_OFFSET_RESET_NV                                    0x90B4
#endif //GL_PATH_DASH_OFFSET_RESET_NV
#ifndef GL_MOVE_TO_RESETS_NV
#define GL_MOVE_TO_RESETS_NV                                            0x90B5
#endif //GL_MOVE_TO_RESETS_NV
#ifndef GL_MOVE_TO_CONTINUES_NV
#define GL_MOVE_TO_CONTINUES_NV                                         0x90B6
#endif //GL_MOVE_TO_CONTINUES_NV
#ifndef GL_PATH_STENCIL_FUNC_NV
#define GL_PATH_STENCIL_FUNC_NV                                         0x90B7
#endif //GL_PATH_STENCIL_FUNC_NV
#ifndef GL_PATH_STENCIL_REF_NV
#define GL_PATH_STENCIL_REF_NV                                          0x90B8
#endif //GL_PATH_STENCIL_REF_NV
#ifndef GL_PATH_STENCIL_VALUE_MASK_NV
#define GL_PATH_STENCIL_VALUE_MASK_NV                                   0x90B9
#endif //GL_PATH_STENCIL_VALUE_MASK_NV
#ifndef GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV
#define GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV                          0x90BD
#endif //GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV
#ifndef GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV
#define GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV                           0x90BE
#endif //GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV
#ifndef GL_PATH_COVER_DEPTH_FUNC_NV
#define GL_PATH_COVER_DEPTH_FUNC_NV                                     0x90BF
#endif //GL_PATH_COVER_DEPTH_FUNC_NV
#ifndef GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE                              0x90C7
#endif //GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
#ifndef GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE
#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE                           0x90C8
#endif //GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE
#ifndef GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS
#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS                          0x90C9
#endif //GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS
#ifndef GL_MAX_VERTEX_IMAGE_UNIFORMS
#define GL_MAX_VERTEX_IMAGE_UNIFORMS                                    0x90CA
#endif //GL_MAX_VERTEX_IMAGE_UNIFORMS
#ifndef GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS
#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS                              0x90CB
#endif //GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS
#ifndef GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS
#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS                           0x90CC
#endif //GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS
#ifndef GL_MAX_GEOMETRY_IMAGE_UNIFORMS
#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS                                  0x90CD
#endif //GL_MAX_GEOMETRY_IMAGE_UNIFORMS
#ifndef GL_MAX_FRAGMENT_IMAGE_UNIFORMS
#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS                                  0x90CE
#endif //GL_MAX_FRAGMENT_IMAGE_UNIFORMS
#ifndef GL_MAX_COMBINED_IMAGE_UNIFORMS
#define GL_MAX_COMBINED_IMAGE_UNIFORMS                                  0x90CF
#endif //GL_MAX_COMBINED_IMAGE_UNIFORMS
#ifndef GL_RESTART_PATH_NV
#define GL_RESTART_PATH_NV                                              0xF0
#endif //GL_RESTART_PATH_NV
#ifndef GL_DUP_FIRST_CUBIC_CURVE_TO_NV
#define GL_DUP_FIRST_CUBIC_CURVE_TO_NV                                  0xF2
#endif //GL_DUP_FIRST_CUBIC_CURVE_TO_NV
#ifndef GL_DUP_LAST_CUBIC_CURVE_TO_NV
#define GL_DUP_LAST_CUBIC_CURVE_TO_NV                                   0xF4
#endif //GL_DUP_LAST_CUBIC_CURVE_TO_NV
#ifndef GL_RECT_NV
#define GL_RECT_NV                                                      0xF6
#endif //GL_RECT_NV
#ifndef GL_CIRCULAR_CCW_ARC_TO_NV
#define GL_CIRCULAR_CCW_ARC_TO_NV                                       0xF8
#endif //GL_CIRCULAR_CCW_ARC_TO_NV
#ifndef GL_CIRCULAR_CW_ARC_TO_NV
#define GL_CIRCULAR_CW_ARC_TO_NV                                        0xFA
#endif //GL_CIRCULAR_CW_ARC_TO_NV
#ifndef GL_CIRCULAR_TANGENT_ARC_TO_NV
#define GL_CIRCULAR_TANGENT_ARC_TO_NV                                   0xFC
#endif //GL_CIRCULAR_TANGENT_ARC_TO_NV
#ifndef GL_ARC_TO_NV
#define GL_ARC_TO_NV                                                    0xFE
#endif //GL_ARC_TO_NV
#ifndef GL_RELATIVE_ARC_TO_NV
#define GL_RELATIVE_ARC_TO_NV                                           0xFF
#endif //GL_RELATIVE_ARC_TO_NV

#endif //GL_NV_path_rendering


typedef GLuint (*PFNGENPATHSNVPROC_HPP)(GLsizei range);

static inline GLuint GenPathsNV(GLsizei range)
{
	static PFNGENPATHSNVPROC_HPP fn=reinterpret_cast<PFNGENPATHSNVPROC_HPP>(_impl::_get_proc_address("glGenPathsNV","GL_NV_path_rendering"));
	return fn(range);
}

typedef void (*PFNDELETEPATHSNVPROC_HPP)(GLuint path,GLsizei range);

static inline void DeletePathsNV(GLuint path,GLsizei range)
{
	static PFNDELETEPATHSNVPROC_HPP fn=reinterpret_cast<PFNDELETEPATHSNVPROC_HPP>(_impl::_get_proc_address("glDeletePathsNV","GL_NV_path_rendering"));
	 fn(path,range);
}

typedef GLboolean (*PFNISPATHNVPROC_HPP)(GLuint path);

static inline GLboolean IsPathNV(GLuint path)
{
	static PFNISPATHNVPROC_HPP fn=reinterpret_cast<PFNISPATHNVPROC_HPP>(_impl::_get_proc_address("glIsPathNV","GL_NV_path_rendering"));
	return fn(path);
}

typedef void (*PFNPATHCOMMANDSNVPROC_HPP)(GLuint path,GLsizei numCommands,const GLubyte *commands,GLsizei numCoords,GLenum coordType,const GLvoid *coords);

static inline void PathCommandsNV(GLuint path,GLsizei numCommands,const GLubyte *commands,GLsizei numCoords,GLenum coordType,const GLvoid *coords)
{
	static PFNPATHCOMMANDSNVPROC_HPP fn=reinterpret_cast<PFNPATHCOMMANDSNVPROC_HPP>(_impl::_get_proc_address("glPathCommandsNV","GL_NV_path_rendering"));
	 fn(path,numCommands,commands,numCoords,coordType,coords);
}

typedef void (*PFNPATHCOORDSNVPROC_HPP)(GLuint path,GLsizei numCoords,GLenum coordType,const GLvoid *coords);

static inline void PathCoordsNV(GLuint path,GLsizei numCoords,GLenum coordType,const GLvoid *coords)
{
	static PFNPATHCOORDSNVPROC_HPP fn=reinterpret_cast<PFNPATHCOORDSNVPROC_HPP>(_impl::_get_proc_address("glPathCoordsNV","GL_NV_path_rendering"));
	 fn(path,numCoords,coordType,coords);
}

typedef void (*PFNPATHSUBCOMMANDSNVPROC_HPP)(GLuint path,GLsizei commandStart,GLsizei commandsToDelete,GLsizei numCommands,const GLubyte *commands,GLsizei numCoords,GLenum coordType,const GLvoid *coords);

static inline void PathSubCommandsNV(GLuint path,GLsizei commandStart,GLsizei commandsToDelete,GLsizei numCommands,const GLubyte *commands,GLsizei numCoords,GLenum coordType,const GLvoid *coords)
{
	static PFNPATHSUBCOMMANDSNVPROC_HPP fn=reinterpret_cast<PFNPATHSUBCOMMANDSNVPROC_HPP>(_impl::_get_proc_address("glPathSubCommandsNV","GL_NV_path_rendering"));
	 fn(path,commandStart,commandsToDelete,numCommands,commands,numCoords,coordType,coords);
}

typedef void (*PFNPATHSUBCOORDSNVPROC_HPP)(GLuint path,GLsizei coordStart,GLsizei numCoords,GLenum coordType,const GLvoid *coords);

static inline void PathSubCoordsNV(GLuint path,GLsizei coordStart,GLsizei numCoords,GLenum coordType,const GLvoid *coords)
{
	static PFNPATHSUBCOORDSNVPROC_HPP fn=reinterpret_cast<PFNPATHSUBCOORDSNVPROC_HPP>(_impl::_get_proc_address("glPathSubCoordsNV","GL_NV_path_rendering"));
	 fn(path,coordStart,numCoords,coordType,coords);
}

typedef void (*PFNPATHSTRINGNVPROC_HPP)(GLuint path,GLenum format,GLsizei length,const GLvoid *pathString);

static inline void PathStringNV(GLuint path,GLenum format,GLsizei length,const GLvoid *pathString)
{
	static PFNPATHSTRINGNVPROC_HPP fn=reinterpret_cast<PFNPATHSTRINGNVPROC_HPP>(_impl::_get_proc_address("glPathStringNV","GL_NV_path_rendering"));
	 fn(path,format,length,pathString);
}

typedef void (*PFNPATHGLYPHSNVPROC_HPP)(GLuint firstPathName,GLenum fontTarget,const GLvoid *fontName,GLbitfield fontStyle,GLsizei numGlyphs,GLenum type,const GLvoid *charcodes,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale);

static inline void PathGlyphsNV(GLuint firstPathName,GLenum fontTarget,const GLvoid *fontName,GLbitfield fontStyle,GLsizei numGlyphs,GLenum type,const GLvoid *charcodes,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale)
{
	static PFNPATHGLYPHSNVPROC_HPP fn=reinterpret_cast<PFNPATHGLYPHSNVPROC_HPP>(_impl::_get_proc_address("glPathGlyphsNV","GL_NV_path_rendering"));
	 fn(firstPathName,fontTarget,fontName,fontStyle,numGlyphs,type,charcodes,handleMissingGlyphs,pathParameterTemplate,emScale);
}

typedef void (*PFNPATHGLYPHRANGENVPROC_HPP)(GLuint firstPathName,GLenum fontTarget,const GLvoid *fontName,GLbitfield fontStyle,GLuint firstGlyph,GLsizei numGlyphs,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale);

static inline void PathGlyphRangeNV(GLuint firstPathName,GLenum fontTarget,const GLvoid *fontName,GLbitfield fontStyle,GLuint firstGlyph,GLsizei numGlyphs,GLenum handleMissingGlyphs,GLuint pathParameterTemplate,GLfloat emScale)
{
	static PFNPATHGLYPHRANGENVPROC_HPP fn=reinterpret_cast<PFNPATHGLYPHRANGENVPROC_HPP>(_impl::_get_proc_address("glPathGlyphRangeNV","GL_NV_path_rendering"));
	 fn(firstPathName,fontTarget,fontName,fontStyle,firstGlyph,numGlyphs,handleMissingGlyphs,pathParameterTemplate,emScale);
}

typedef void (*PFNWEIGHTPATHSNVPROC_HPP)(GLuint resultPath,GLsizei numPaths,const GLuint *paths,const GLfloat *weights);

static inline void WeightPathsNV(GLuint resultPath,GLsizei numPaths,const GLuint *paths,const GLfloat *weights)
{
	static PFNWEIGHTPATHSNVPROC_HPP fn=reinterpret_cast<PFNWEIGHTPATHSNVPROC_HPP>(_impl::_get_proc_address("glWeightPathsNV","GL_NV_path_rendering"));
	 fn(resultPath,numPaths,paths,weights);
}

typedef void (*PFNCOPYPATHNVPROC_HPP)(GLuint resultPath,GLuint srcPath);

static inline void CopyPathNV(GLuint resultPath,GLuint srcPath)
{
	static PFNCOPYPATHNVPROC_HPP fn=reinterpret_cast<PFNCOPYPATHNVPROC_HPP>(_impl::_get_proc_address("glCopyPathNV","GL_NV_path_rendering"));
	 fn(resultPath,srcPath);
}

typedef void (*PFNINTERPOLATEPATHSNVPROC_HPP)(GLuint resultPath,GLuint pathA,GLuint pathB,GLfloat weight);

static inline void InterpolatePathsNV(GLuint resultPath,GLuint pathA,GLuint pathB,GLfloat weight)
{
	static PFNINTERPOLATEPATHSNVPROC_HPP fn=reinterpret_cast<PFNINTERPOLATEPATHSNVPROC_HPP>(_impl::_get_proc_address("glInterpolatePathsNV","GL_NV_path_rendering"));
	 fn(resultPath,pathA,pathB,weight);
}

typedef void (*PFNTRANSFORMPATHNVPROC_HPP)(GLuint resultPath,GLuint srcPath,GLenum transformType,const GLfloat *transformValues);

static inline void TransformPathNV(GLuint resultPath,GLuint srcPath,GLenum transformType,const GLfloat *transformValues)
{
	static PFNTRANSFORMPATHNVPROC_HPP fn=reinterpret_cast<PFNTRANSFORMPATHNVPROC_HPP>(_impl::_get_proc_address("glTransformPathNV","GL_NV_path_rendering"));
	 fn(resultPath,srcPath,transformType,transformValues);
}

typedef void (*PFNPATHPARAMETERIVNVPROC_HPP)(GLuint path,GLenum pname,const GLint *value);

static inline void PathParameterivNV(GLuint path,GLenum pname,const GLint *value)
{
	static PFNPATHPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNPATHPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glPathParameterivNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNPATHPARAMETERINVPROC_HPP)(GLuint path,GLenum pname,GLint value);

static inline void PathParameteriNV(GLuint path,GLenum pname,GLint value)
{
	static PFNPATHPARAMETERINVPROC_HPP fn=reinterpret_cast<PFNPATHPARAMETERINVPROC_HPP>(_impl::_get_proc_address("glPathParameteriNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNPATHPARAMETERFVNVPROC_HPP)(GLuint path,GLenum pname,const GLfloat *value);

static inline void PathParameterfvNV(GLuint path,GLenum pname,const GLfloat *value)
{
	static PFNPATHPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNPATHPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glPathParameterfvNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNPATHPARAMETERFNVPROC_HPP)(GLuint path,GLenum pname,GLfloat value);

static inline void PathParameterfNV(GLuint path,GLenum pname,GLfloat value)
{
	static PFNPATHPARAMETERFNVPROC_HPP fn=reinterpret_cast<PFNPATHPARAMETERFNVPROC_HPP>(_impl::_get_proc_address("glPathParameterfNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNPATHDASHARRAYNVPROC_HPP)(GLuint path,GLsizei dashCount,const GLfloat *dashArray);

static inline void PathDashArrayNV(GLuint path,GLsizei dashCount,const GLfloat *dashArray)
{
	static PFNPATHDASHARRAYNVPROC_HPP fn=reinterpret_cast<PFNPATHDASHARRAYNVPROC_HPP>(_impl::_get_proc_address("glPathDashArrayNV","GL_NV_path_rendering"));
	 fn(path,dashCount,dashArray);
}

typedef void (*PFNPATHSTENCILFUNCNVPROC_HPP)(GLenum func,GLint ref,GLuint mask);

static inline void PathStencilFuncNV(GLenum func,GLint ref,GLuint mask)
{
	static PFNPATHSTENCILFUNCNVPROC_HPP fn=reinterpret_cast<PFNPATHSTENCILFUNCNVPROC_HPP>(_impl::_get_proc_address("glPathStencilFuncNV","GL_NV_path_rendering"));
	 fn(func,ref,mask);
}

typedef void (*PFNPATHSTENCILDEPTHOFFSETNVPROC_HPP)(GLfloat factor,GLfloat units);

static inline void PathStencilDepthOffsetNV(GLfloat factor,GLfloat units)
{
	static PFNPATHSTENCILDEPTHOFFSETNVPROC_HPP fn=reinterpret_cast<PFNPATHSTENCILDEPTHOFFSETNVPROC_HPP>(_impl::_get_proc_address("glPathStencilDepthOffsetNV","GL_NV_path_rendering"));
	 fn(factor,units);
}

typedef void (*PFNSTENCILFILLPATHNVPROC_HPP)(GLuint path,GLenum fillMode,GLuint mask);

static inline void StencilFillPathNV(GLuint path,GLenum fillMode,GLuint mask)
{
	static PFNSTENCILFILLPATHNVPROC_HPP fn=reinterpret_cast<PFNSTENCILFILLPATHNVPROC_HPP>(_impl::_get_proc_address("glStencilFillPathNV","GL_NV_path_rendering"));
	 fn(path,fillMode,mask);
}

typedef void (*PFNSTENCILSTROKEPATHNVPROC_HPP)(GLuint path,GLint reference,GLuint mask);

static inline void StencilStrokePathNV(GLuint path,GLint reference,GLuint mask)
{
	static PFNSTENCILSTROKEPATHNVPROC_HPP fn=reinterpret_cast<PFNSTENCILSTROKEPATHNVPROC_HPP>(_impl::_get_proc_address("glStencilStrokePathNV","GL_NV_path_rendering"));
	 fn(path,reference,mask);
}

typedef void (*PFNSTENCILFILLPATHINSTANCEDNVPROC_HPP)(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum transformType,const GLfloat *transformValues);

static inline void StencilFillPathInstancedNV(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum fillMode,GLuint mask,GLenum transformType,const GLfloat *transformValues)
{
	static PFNSTENCILFILLPATHINSTANCEDNVPROC_HPP fn=reinterpret_cast<PFNSTENCILFILLPATHINSTANCEDNVPROC_HPP>(_impl::_get_proc_address("glStencilFillPathInstancedNV","GL_NV_path_rendering"));
	 fn(numPaths,pathNameType,paths,pathBase,fillMode,mask,transformType,transformValues);
}

typedef void (*PFNSTENCILSTROKEPATHINSTANCEDNVPROC_HPP)(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLint reference,GLuint mask,GLenum transformType,const GLfloat *transformValues);

static inline void StencilStrokePathInstancedNV(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLint reference,GLuint mask,GLenum transformType,const GLfloat *transformValues)
{
	static PFNSTENCILSTROKEPATHINSTANCEDNVPROC_HPP fn=reinterpret_cast<PFNSTENCILSTROKEPATHINSTANCEDNVPROC_HPP>(_impl::_get_proc_address("glStencilStrokePathInstancedNV","GL_NV_path_rendering"));
	 fn(numPaths,pathNameType,paths,pathBase,reference,mask,transformType,transformValues);
}

typedef void (*PFNPATHCOVERDEPTHFUNCNVPROC_HPP)(GLenum func);

static inline void PathCoverDepthFuncNV(GLenum func)
{
	static PFNPATHCOVERDEPTHFUNCNVPROC_HPP fn=reinterpret_cast<PFNPATHCOVERDEPTHFUNCNVPROC_HPP>(_impl::_get_proc_address("glPathCoverDepthFuncNV","GL_NV_path_rendering"));
	 fn(func);
}

typedef void (*PFNPATHCOLORGENNVPROC_HPP)(GLenum color,GLenum genMode,GLenum colorFormat,const GLfloat *coeffs);

static inline void PathColorGenNV(GLenum color,GLenum genMode,GLenum colorFormat,const GLfloat *coeffs)
{
	static PFNPATHCOLORGENNVPROC_HPP fn=reinterpret_cast<PFNPATHCOLORGENNVPROC_HPP>(_impl::_get_proc_address("glPathColorGenNV","GL_NV_path_rendering"));
	 fn(color,genMode,colorFormat,coeffs);
}

typedef void (*PFNPATHTEXGENNVPROC_HPP)(GLenum texCoordSet,GLenum genMode,GLint components,const GLfloat *coeffs);

static inline void PathTexGenNV(GLenum texCoordSet,GLenum genMode,GLint components,const GLfloat *coeffs)
{
	static PFNPATHTEXGENNVPROC_HPP fn=reinterpret_cast<PFNPATHTEXGENNVPROC_HPP>(_impl::_get_proc_address("glPathTexGenNV","GL_NV_path_rendering"));
	 fn(texCoordSet,genMode,components,coeffs);
}

typedef void (*PFNPATHFOGGENNVPROC_HPP)(GLenum genMode);

static inline void PathFogGenNV(GLenum genMode)
{
	static PFNPATHFOGGENNVPROC_HPP fn=reinterpret_cast<PFNPATHFOGGENNVPROC_HPP>(_impl::_get_proc_address("glPathFogGenNV","GL_NV_path_rendering"));
	 fn(genMode);
}

typedef void (*PFNCOVERFILLPATHNVPROC_HPP)(GLuint path,GLenum coverMode);

static inline void CoverFillPathNV(GLuint path,GLenum coverMode)
{
	static PFNCOVERFILLPATHNVPROC_HPP fn=reinterpret_cast<PFNCOVERFILLPATHNVPROC_HPP>(_impl::_get_proc_address("glCoverFillPathNV","GL_NV_path_rendering"));
	 fn(path,coverMode);
}

typedef void (*PFNCOVERSTROKEPATHNVPROC_HPP)(GLuint path,GLenum coverMode);

static inline void CoverStrokePathNV(GLuint path,GLenum coverMode)
{
	static PFNCOVERSTROKEPATHNVPROC_HPP fn=reinterpret_cast<PFNCOVERSTROKEPATHNVPROC_HPP>(_impl::_get_proc_address("glCoverStrokePathNV","GL_NV_path_rendering"));
	 fn(path,coverMode);
}

typedef void (*PFNCOVERFILLPATHINSTANCEDNVPROC_HPP)(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat *transformValues);

static inline void CoverFillPathInstancedNV(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat *transformValues)
{
	static PFNCOVERFILLPATHINSTANCEDNVPROC_HPP fn=reinterpret_cast<PFNCOVERFILLPATHINSTANCEDNVPROC_HPP>(_impl::_get_proc_address("glCoverFillPathInstancedNV","GL_NV_path_rendering"));
	 fn(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues);
}

typedef void (*PFNCOVERSTROKEPATHINSTANCEDNVPROC_HPP)(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat *transformValues);

static inline void CoverStrokePathInstancedNV(GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLenum coverMode,GLenum transformType,const GLfloat *transformValues)
{
	static PFNCOVERSTROKEPATHINSTANCEDNVPROC_HPP fn=reinterpret_cast<PFNCOVERSTROKEPATHINSTANCEDNVPROC_HPP>(_impl::_get_proc_address("glCoverStrokePathInstancedNV","GL_NV_path_rendering"));
	 fn(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues);
}

typedef void (*PFNGETPATHPARAMETERIVNVPROC_HPP)(GLuint path,GLenum pname,GLint *value);

static inline void GetPathParameterivNV(GLuint path,GLenum pname,GLint *value)
{
	static PFNGETPATHPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetPathParameterivNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNGETPATHPARAMETERFVNVPROC_HPP)(GLuint path,GLenum pname,GLfloat *value);

static inline void GetPathParameterfvNV(GLuint path,GLenum pname,GLfloat *value)
{
	static PFNGETPATHPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetPathParameterfvNV","GL_NV_path_rendering"));
	 fn(path,pname,value);
}

typedef void (*PFNGETPATHCOMMANDSNVPROC_HPP)(GLuint path,GLubyte *commands);

static inline void GetPathCommandsNV(GLuint path,GLubyte *commands)
{
	static PFNGETPATHCOMMANDSNVPROC_HPP fn=reinterpret_cast<PFNGETPATHCOMMANDSNVPROC_HPP>(_impl::_get_proc_address("glGetPathCommandsNV","GL_NV_path_rendering"));
	 fn(path,commands);
}

typedef void (*PFNGETPATHCOORDSNVPROC_HPP)(GLuint path,GLfloat *coords);

static inline void GetPathCoordsNV(GLuint path,GLfloat *coords)
{
	static PFNGETPATHCOORDSNVPROC_HPP fn=reinterpret_cast<PFNGETPATHCOORDSNVPROC_HPP>(_impl::_get_proc_address("glGetPathCoordsNV","GL_NV_path_rendering"));
	 fn(path,coords);
}

typedef void (*PFNGETPATHDASHARRAYNVPROC_HPP)(GLuint path,GLfloat *dashArray);

static inline void GetPathDashArrayNV(GLuint path,GLfloat *dashArray)
{
	static PFNGETPATHDASHARRAYNVPROC_HPP fn=reinterpret_cast<PFNGETPATHDASHARRAYNVPROC_HPP>(_impl::_get_proc_address("glGetPathDashArrayNV","GL_NV_path_rendering"));
	 fn(path,dashArray);
}

typedef void (*PFNGETPATHMETRICSNVPROC_HPP)(GLbitfield metricQueryMask,GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLsizei stride,GLfloat *metrics);

static inline void GetPathMetricsNV(GLbitfield metricQueryMask,GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLsizei stride,GLfloat *metrics)
{
	static PFNGETPATHMETRICSNVPROC_HPP fn=reinterpret_cast<PFNGETPATHMETRICSNVPROC_HPP>(_impl::_get_proc_address("glGetPathMetricsNV","GL_NV_path_rendering"));
	 fn(metricQueryMask,numPaths,pathNameType,paths,pathBase,stride,metrics);
}

typedef void (*PFNGETPATHMETRICRANGENVPROC_HPP)(GLbitfield metricQueryMask,GLuint firstPathName,GLsizei numPaths,GLsizei stride,GLfloat *metrics);

static inline void GetPathMetricRangeNV(GLbitfield metricQueryMask,GLuint firstPathName,GLsizei numPaths,GLsizei stride,GLfloat *metrics)
{
	static PFNGETPATHMETRICRANGENVPROC_HPP fn=reinterpret_cast<PFNGETPATHMETRICRANGENVPROC_HPP>(_impl::_get_proc_address("glGetPathMetricRangeNV","GL_NV_path_rendering"));
	 fn(metricQueryMask,firstPathName,numPaths,stride,metrics);
}

typedef void (*PFNGETPATHSPACINGNVPROC_HPP)(GLenum pathListMode,GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLfloat advanceScale,GLfloat kerningScale,GLenum transformType,GLfloat *returnedSpacing);

static inline void GetPathSpacingNV(GLenum pathListMode,GLsizei numPaths,GLenum pathNameType,const GLvoid *paths,GLuint pathBase,GLfloat advanceScale,GLfloat kerningScale,GLenum transformType,GLfloat *returnedSpacing)
{
	static PFNGETPATHSPACINGNVPROC_HPP fn=reinterpret_cast<PFNGETPATHSPACINGNVPROC_HPP>(_impl::_get_proc_address("glGetPathSpacingNV","GL_NV_path_rendering"));
	 fn(pathListMode,numPaths,pathNameType,paths,pathBase,advanceScale,kerningScale,transformType,returnedSpacing);
}

typedef void (*PFNGETPATHCOLORGENIVNVPROC_HPP)(GLenum color,GLenum pname,GLint *value);

static inline void GetPathColorGenivNV(GLenum color,GLenum pname,GLint *value)
{
	static PFNGETPATHCOLORGENIVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHCOLORGENIVNVPROC_HPP>(_impl::_get_proc_address("glGetPathColorGenivNV","GL_NV_path_rendering"));
	 fn(color,pname,value);
}

typedef void (*PFNGETPATHCOLORGENFVNVPROC_HPP)(GLenum color,GLenum pname,GLfloat *value);

static inline void GetPathColorGenfvNV(GLenum color,GLenum pname,GLfloat *value)
{
	static PFNGETPATHCOLORGENFVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHCOLORGENFVNVPROC_HPP>(_impl::_get_proc_address("glGetPathColorGenfvNV","GL_NV_path_rendering"));
	 fn(color,pname,value);
}

typedef void (*PFNGETPATHTEXGENIVNVPROC_HPP)(GLenum texCoordSet,GLenum pname,GLint *value);

static inline void GetPathTexGenivNV(GLenum texCoordSet,GLenum pname,GLint *value)
{
	static PFNGETPATHTEXGENIVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHTEXGENIVNVPROC_HPP>(_impl::_get_proc_address("glGetPathTexGenivNV","GL_NV_path_rendering"));
	 fn(texCoordSet,pname,value);
}

typedef void (*PFNGETPATHTEXGENFVNVPROC_HPP)(GLenum texCoordSet,GLenum pname,GLfloat *value);

static inline void GetPathTexGenfvNV(GLenum texCoordSet,GLenum pname,GLfloat *value)
{
	static PFNGETPATHTEXGENFVNVPROC_HPP fn=reinterpret_cast<PFNGETPATHTEXGENFVNVPROC_HPP>(_impl::_get_proc_address("glGetPathTexGenfvNV","GL_NV_path_rendering"));
	 fn(texCoordSet,pname,value);
}

typedef GLboolean (*PFNISPOINTINFILLPATHNVPROC_HPP)(GLuint path,GLuint mask,GLfloat x,GLfloat y);

static inline GLboolean IsPointInFillPathNV(GLuint path,GLuint mask,GLfloat x,GLfloat y)
{
	static PFNISPOINTINFILLPATHNVPROC_HPP fn=reinterpret_cast<PFNISPOINTINFILLPATHNVPROC_HPP>(_impl::_get_proc_address("glIsPointInFillPathNV","GL_NV_path_rendering"));
	return fn(path,mask,x,y);
}

typedef GLboolean (*PFNISPOINTINSTROKEPATHNVPROC_HPP)(GLuint path,GLfloat x,GLfloat y);

static inline GLboolean IsPointInStrokePathNV(GLuint path,GLfloat x,GLfloat y)
{
	static PFNISPOINTINSTROKEPATHNVPROC_HPP fn=reinterpret_cast<PFNISPOINTINSTROKEPATHNVPROC_HPP>(_impl::_get_proc_address("glIsPointInStrokePathNV","GL_NV_path_rendering"));
	return fn(path,x,y);
}

typedef GLfloat (*PFNGETPATHLENGTHNVPROC_HPP)(GLuint path,GLsizei startSegment,GLsizei numSegments);

static inline GLfloat GetPathLengthNV(GLuint path,GLsizei startSegment,GLsizei numSegments)
{
	static PFNGETPATHLENGTHNVPROC_HPP fn=reinterpret_cast<PFNGETPATHLENGTHNVPROC_HPP>(_impl::_get_proc_address("glGetPathLengthNV","GL_NV_path_rendering"));
	return fn(path,startSegment,numSegments);
}

typedef GLboolean (*PFNPOINTALONGPATHNVPROC_HPP)(GLuint path,GLsizei startSegment,GLsizei numSegments,GLfloat distance,GLfloat *x,GLfloat *y,GLfloat *tangentX,GLfloat *tangentY);

static inline GLboolean PointAlongPathNV(GLuint path,GLsizei startSegment,GLsizei numSegments,GLfloat distance,GLfloat *x,GLfloat *y,GLfloat *tangentX,GLfloat *tangentY)
{
	static PFNPOINTALONGPATHNVPROC_HPP fn=reinterpret_cast<PFNPOINTALONGPATHNVPROC_HPP>(_impl::_get_proc_address("glPointAlongPathNV","GL_NV_path_rendering"));
	return fn(path,startSegment,numSegments,distance,x,y,tangentX,tangentY);
}
#ifndef GL_NV_pixel_data_range

#define GL_NV_pixel_data_range
#ifndef GL_WRITE_PIXEL_DATA_RANGE_NV
#define GL_WRITE_PIXEL_DATA_RANGE_NV                                    0x8878
#endif //GL_WRITE_PIXEL_DATA_RANGE_NV
#ifndef GL_READ_PIXEL_DATA_RANGE_NV
#define GL_READ_PIXEL_DATA_RANGE_NV                                     0x8879
#endif //GL_READ_PIXEL_DATA_RANGE_NV
#ifndef GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV
#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV                             0x887A
#endif //GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV
#ifndef GL_READ_PIXEL_DATA_RANGE_LENGTH_NV
#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV                              0x887B
#endif //GL_READ_PIXEL_DATA_RANGE_LENGTH_NV
#ifndef GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV
#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV                            0x887C
#endif //GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV
#ifndef GL_READ_PIXEL_DATA_RANGE_POINTER_NV
#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV                             0x887D
#endif //GL_READ_PIXEL_DATA_RANGE_POINTER_NV

#endif //GL_NV_pixel_data_range


typedef void (*PFNPIXELDATARANGENVPROC_HPP)(GLenum target,GLsizei length,const GLvoid *pointer);

static inline void PixelDataRangeNV(GLenum target,GLsizei length,const GLvoid *pointer)
{
	static PFNPIXELDATARANGENVPROC_HPP fn=reinterpret_cast<PFNPIXELDATARANGENVPROC_HPP>(_impl::_get_proc_address("glPixelDataRangeNV","GL_NV_pixel_data_range"));
	 fn(target,length,pointer);
}

typedef void (*PFNFLUSHPIXELDATARANGENVPROC_HPP)(GLenum target);

static inline void FlushPixelDataRangeNV(GLenum target)
{
	static PFNFLUSHPIXELDATARANGENVPROC_HPP fn=reinterpret_cast<PFNFLUSHPIXELDATARANGENVPROC_HPP>(_impl::_get_proc_address("glFlushPixelDataRangeNV","GL_NV_pixel_data_range"));
	 fn(target);
}
#ifndef GL_NV_point_sprite

#define GL_NV_point_sprite
#ifndef GL_POINT_SPRITE_NV
#define GL_POINT_SPRITE_NV                                              0x8861
#endif //GL_POINT_SPRITE_NV
#ifndef GL_COORD_REPLACE_NV
#define GL_COORD_REPLACE_NV                                             0x8862
#endif //GL_COORD_REPLACE_NV
#ifndef GL_POINT_SPRITE_R_MODE_NV
#define GL_POINT_SPRITE_R_MODE_NV                                       0x8863
#endif //GL_POINT_SPRITE_R_MODE_NV

#endif //GL_NV_point_sprite


typedef void (*PFNPOINTPARAMETERINVPROC_HPP)(GLenum pname,GLint param);

static inline void PointParameteriNV(GLenum pname,GLint param)
{
	static PFNPOINTPARAMETERINVPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERINVPROC_HPP>(_impl::_get_proc_address("glPointParameteriNV","GL_NV_point_sprite"));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERIVNVPROC_HPP)(GLenum pname,const GLint *params);

static inline void PointParameterivNV(GLenum pname,const GLint *params)
{
	static PFNPOINTPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glPointParameterivNV","GL_NV_point_sprite"));
	 fn(pname,params);
}
#ifndef GL_NV_present_video

#define GL_NV_present_video
#ifndef GL_FRAME_NV
#define GL_FRAME_NV                                                     0x8E26
#endif //GL_FRAME_NV
#ifndef GL_FIELDS_NV
#define GL_FIELDS_NV                                                    0x8E27
#endif //GL_FIELDS_NV
#ifndef GL_CURRENT_TIME_NV
#define GL_CURRENT_TIME_NV                                              0x8E28
#endif //GL_CURRENT_TIME_NV
#ifndef GL_NUM_FILL_STREAMS_NV
#define GL_NUM_FILL_STREAMS_NV                                          0x8E29
#endif //GL_NUM_FILL_STREAMS_NV
#ifndef GL_PRESENT_TIME_NV
#define GL_PRESENT_TIME_NV                                              0x8E2A
#endif //GL_PRESENT_TIME_NV
#ifndef GL_PRESENT_DURATION_NV
#define GL_PRESENT_DURATION_NV                                          0x8E2B
#endif //GL_PRESENT_DURATION_NV

#endif //GL_NV_present_video


typedef void (*PFNPRESENTFRAMEKEYEDNVPROC_HPP)(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLuint key0,GLenum target1,GLuint fill1,GLuint key1);

static inline void PresentFrameKeyedNV(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLuint key0,GLenum target1,GLuint fill1,GLuint key1)
{
	static PFNPRESENTFRAMEKEYEDNVPROC_HPP fn=reinterpret_cast<PFNPRESENTFRAMEKEYEDNVPROC_HPP>(_impl::_get_proc_address("glPresentFrameKeyedNV","GL_NV_present_video"));
	 fn(video_slot,minPresentTime,beginPresentTimeId,presentDurationId,type,target0,fill0,key0,target1,fill1,key1);
}

typedef void (*PFNPRESENTFRAMEDUALFILLNVPROC_HPP)(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLenum target1,GLuint fill1,GLenum target2,GLuint fill2,GLenum target3,GLuint fill3);

static inline void PresentFrameDualFillNV(GLuint video_slot,GLuint64EXT minPresentTime,GLuint beginPresentTimeId,GLuint presentDurationId,GLenum type,GLenum target0,GLuint fill0,GLenum target1,GLuint fill1,GLenum target2,GLuint fill2,GLenum target3,GLuint fill3)
{
	static PFNPRESENTFRAMEDUALFILLNVPROC_HPP fn=reinterpret_cast<PFNPRESENTFRAMEDUALFILLNVPROC_HPP>(_impl::_get_proc_address("glPresentFrameDualFillNV","GL_NV_present_video"));
	 fn(video_slot,minPresentTime,beginPresentTimeId,presentDurationId,type,target0,fill0,target1,fill1,target2,fill2,target3,fill3);
}

typedef void (*PFNGETVIDEOIVNVPROC_HPP)(GLuint video_slot,GLenum pname,GLint *params);

static inline void GetVideoivNV(GLuint video_slot,GLenum pname,GLint *params)
{
	static PFNGETVIDEOIVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOIVNVPROC_HPP>(_impl::_get_proc_address("glGetVideoivNV","GL_NV_present_video"));
	 fn(video_slot,pname,params);
}

typedef void (*PFNGETVIDEOUIVNVPROC_HPP)(GLuint video_slot,GLenum pname,GLuint *params);

static inline void GetVideouivNV(GLuint video_slot,GLenum pname,GLuint *params)
{
	static PFNGETVIDEOUIVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOUIVNVPROC_HPP>(_impl::_get_proc_address("glGetVideouivNV","GL_NV_present_video"));
	 fn(video_slot,pname,params);
}

typedef void (*PFNGETVIDEOI64VNVPROC_HPP)(GLuint video_slot,GLenum pname,GLint64EXT *params);

static inline void GetVideoi64vNV(GLuint video_slot,GLenum pname,GLint64EXT *params)
{
	static PFNGETVIDEOI64VNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOI64VNVPROC_HPP>(_impl::_get_proc_address("glGetVideoi64vNV","GL_NV_present_video"));
	 fn(video_slot,pname,params);
}

typedef void (*PFNGETVIDEOUI64VNVPROC_HPP)(GLuint video_slot,GLenum pname,GLuint64EXT *params);

static inline void GetVideoui64vNV(GLuint video_slot,GLenum pname,GLuint64EXT *params)
{
	static PFNGETVIDEOUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetVideoui64vNV","GL_NV_present_video"));
	 fn(video_slot,pname,params);
}
#ifndef GL_NV_primitive_restart

#define GL_NV_primitive_restart
#ifndef GL_PRIMITIVE_RESTART_NV
#define GL_PRIMITIVE_RESTART_NV                                         0x8558
#endif //GL_PRIMITIVE_RESTART_NV
#ifndef GL_PRIMITIVE_RESTART_INDEX_NV
#define GL_PRIMITIVE_RESTART_INDEX_NV                                   0x8559
#endif //GL_PRIMITIVE_RESTART_INDEX_NV

#endif //GL_NV_primitive_restart


typedef void (*PFNPRIMITIVERESTARTNVPROC_HPP)();

static inline void PrimitiveRestartNV()
{
	static PFNPRIMITIVERESTARTNVPROC_HPP fn=reinterpret_cast<PFNPRIMITIVERESTARTNVPROC_HPP>(_impl::_get_proc_address("glPrimitiveRestartNV","GL_NV_primitive_restart"));
	 fn();
}

typedef void (*PFNPRIMITIVERESTARTINDEXNVPROC_HPP)(GLuint index);

static inline void PrimitiveRestartIndexNV(GLuint index)
{
	static PFNPRIMITIVERESTARTINDEXNVPROC_HPP fn=reinterpret_cast<PFNPRIMITIVERESTARTINDEXNVPROC_HPP>(_impl::_get_proc_address("glPrimitiveRestartIndexNV","GL_NV_primitive_restart"));
	 fn(index);
}
#ifndef GL_NV_read_buffer

#define GL_NV_read_buffer
#ifndef GL_READ_BUFFER_NV
#define GL_READ_BUFFER_NV                                               0x0C02
#endif //GL_READ_BUFFER_NV

#endif //GL_NV_read_buffer

#ifndef GL_NV_register_combiners

#define GL_NV_register_combiners
#ifndef GL_REGISTER_COMBINERS_NV
#define GL_REGISTER_COMBINERS_NV                                        0x8522
#endif //GL_REGISTER_COMBINERS_NV
#ifndef GL_VARIABLE_A_NV
#define GL_VARIABLE_A_NV                                                0x8523
#endif //GL_VARIABLE_A_NV
#ifndef GL_VARIABLE_B_NV
#define GL_VARIABLE_B_NV                                                0x8524
#endif //GL_VARIABLE_B_NV
#ifndef GL_VARIABLE_C_NV
#define GL_VARIABLE_C_NV                                                0x8525
#endif //GL_VARIABLE_C_NV
#ifndef GL_VARIABLE_D_NV
#define GL_VARIABLE_D_NV                                                0x8526
#endif //GL_VARIABLE_D_NV
#ifndef GL_VARIABLE_E_NV
#define GL_VARIABLE_E_NV                                                0x8527
#endif //GL_VARIABLE_E_NV
#ifndef GL_VARIABLE_F_NV
#define GL_VARIABLE_F_NV                                                0x8528
#endif //GL_VARIABLE_F_NV
#ifndef GL_VARIABLE_G_NV
#define GL_VARIABLE_G_NV                                                0x8529
#endif //GL_VARIABLE_G_NV
#ifndef GL_CONSTANT_COLOR0_NV
#define GL_CONSTANT_COLOR0_NV                                           0x852A
#endif //GL_CONSTANT_COLOR0_NV
#ifndef GL_CONSTANT_COLOR1_NV
#define GL_CONSTANT_COLOR1_NV                                           0x852B
#endif //GL_CONSTANT_COLOR1_NV
#ifndef GL_PRIMARY_COLOR_NV
#define GL_PRIMARY_COLOR_NV                                             0x852C
#endif //GL_PRIMARY_COLOR_NV
#ifndef GL_SECONDARY_COLOR_NV
#define GL_SECONDARY_COLOR_NV                                           0x852D
#endif //GL_SECONDARY_COLOR_NV
#ifndef GL_SPARE0_NV
#define GL_SPARE0_NV                                                    0x852E
#endif //GL_SPARE0_NV
#ifndef GL_SPARE1_NV
#define GL_SPARE1_NV                                                    0x852F
#endif //GL_SPARE1_NV
#ifndef GL_DISCARD_NV
#define GL_DISCARD_NV                                                   0x8530
#endif //GL_DISCARD_NV
#ifndef GL_E_TIMES_F_NV
#define GL_E_TIMES_F_NV                                                 0x8531
#endif //GL_E_TIMES_F_NV
#ifndef GL_SPARE0_PLUS_SECONDARY_COLOR_NV
#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV                               0x8532
#endif //GL_SPARE0_PLUS_SECONDARY_COLOR_NV
#ifndef GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV
#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV                          0x8533
#endif //GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV
#ifndef GL_MULTISAMPLE_FILTER_HINT_NV
#define GL_MULTISAMPLE_FILTER_HINT_NV                                   0x8534
#endif //GL_MULTISAMPLE_FILTER_HINT_NV
#ifndef GL_UNSIGNED_IDENTITY_NV
#define GL_UNSIGNED_IDENTITY_NV                                         0x8536
#endif //GL_UNSIGNED_IDENTITY_NV
#ifndef GL_UNSIGNED_INVERT_NV
#define GL_UNSIGNED_INVERT_NV                                           0x8537
#endif //GL_UNSIGNED_INVERT_NV
#ifndef GL_EXPAND_NORMAL_NV
#define GL_EXPAND_NORMAL_NV                                             0x8538
#endif //GL_EXPAND_NORMAL_NV
#ifndef GL_EXPAND_NEGATE_NV
#define GL_EXPAND_NEGATE_NV                                             0x8539
#endif //GL_EXPAND_NEGATE_NV
#ifndef GL_HALF_BIAS_NORMAL_NV
#define GL_HALF_BIAS_NORMAL_NV                                          0x853A
#endif //GL_HALF_BIAS_NORMAL_NV
#ifndef GL_HALF_BIAS_NEGATE_NV
#define GL_HALF_BIAS_NEGATE_NV                                          0x853B
#endif //GL_HALF_BIAS_NEGATE_NV
#ifndef GL_SIGNED_IDENTITY_NV
#define GL_SIGNED_IDENTITY_NV                                           0x853C
#endif //GL_SIGNED_IDENTITY_NV
#ifndef GL_UNSIGNED_NEGATE_NV
#define GL_UNSIGNED_NEGATE_NV                                           0x853D
#endif //GL_UNSIGNED_NEGATE_NV
#ifndef GL_SCALE_BY_TWO_NV
#define GL_SCALE_BY_TWO_NV                                              0x853E
#endif //GL_SCALE_BY_TWO_NV
#ifndef GL_SCALE_BY_FOUR_NV
#define GL_SCALE_BY_FOUR_NV                                             0x853F
#endif //GL_SCALE_BY_FOUR_NV
#ifndef GL_SCALE_BY_ONE_HALF_NV
#define GL_SCALE_BY_ONE_HALF_NV                                         0x8540
#endif //GL_SCALE_BY_ONE_HALF_NV
#ifndef GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV                                 0x8541
#endif //GL_BIAS_BY_NEGATIVE_ONE_HALF_NV
#ifndef GL_COMBINER_INPUT_NV
#define GL_COMBINER_INPUT_NV                                            0x8542
#endif //GL_COMBINER_INPUT_NV
#ifndef GL_COMBINER_MAPPING_NV
#define GL_COMBINER_MAPPING_NV                                          0x8543
#endif //GL_COMBINER_MAPPING_NV
#ifndef GL_COMBINER_COMPONENT_USAGE_NV
#define GL_COMBINER_COMPONENT_USAGE_NV                                  0x8544
#endif //GL_COMBINER_COMPONENT_USAGE_NV
#ifndef GL_COMBINER_AB_DOT_PRODUCT_NV
#define GL_COMBINER_AB_DOT_PRODUCT_NV                                   0x8545
#endif //GL_COMBINER_AB_DOT_PRODUCT_NV
#ifndef GL_COMBINER_CD_DOT_PRODUCT_NV
#define GL_COMBINER_CD_DOT_PRODUCT_NV                                   0x8546
#endif //GL_COMBINER_CD_DOT_PRODUCT_NV
#ifndef GL_COMBINER_MUX_SUM_NV
#define GL_COMBINER_MUX_SUM_NV                                          0x8547
#endif //GL_COMBINER_MUX_SUM_NV
#ifndef GL_COMBINER_SCALE_NV
#define GL_COMBINER_SCALE_NV                                            0x8548
#endif //GL_COMBINER_SCALE_NV
#ifndef GL_COMBINER_BIAS_NV
#define GL_COMBINER_BIAS_NV                                             0x8549
#endif //GL_COMBINER_BIAS_NV
#ifndef GL_COMBINER_AB_OUTPUT_NV
#define GL_COMBINER_AB_OUTPUT_NV                                        0x854A
#endif //GL_COMBINER_AB_OUTPUT_NV
#ifndef GL_COMBINER_CD_OUTPUT_NV
#define GL_COMBINER_CD_OUTPUT_NV                                        0x854B
#endif //GL_COMBINER_CD_OUTPUT_NV
#ifndef GL_COMBINER_SUM_OUTPUT_NV
#define GL_COMBINER_SUM_OUTPUT_NV                                       0x854C
#endif //GL_COMBINER_SUM_OUTPUT_NV
#ifndef GL_MAX_GENERAL_COMBINERS_NV
#define GL_MAX_GENERAL_COMBINERS_NV                                     0x854D
#endif //GL_MAX_GENERAL_COMBINERS_NV
#ifndef GL_NUM_GENERAL_COMBINERS_NV
#define GL_NUM_GENERAL_COMBINERS_NV                                     0x854E
#endif //GL_NUM_GENERAL_COMBINERS_NV
#ifndef GL_COLOR_SUM_CLAMP_NV
#define GL_COLOR_SUM_CLAMP_NV                                           0x854F
#endif //GL_COLOR_SUM_CLAMP_NV
#ifndef GL_COMBINER0_NV
#define GL_COMBINER0_NV                                                 0x8550
#endif //GL_COMBINER0_NV
#ifndef GL_COMBINER1_NV
#define GL_COMBINER1_NV                                                 0x8551
#endif //GL_COMBINER1_NV
#ifndef GL_COMBINER2_NV
#define GL_COMBINER2_NV                                                 0x8552
#endif //GL_COMBINER2_NV
#ifndef GL_COMBINER3_NV
#define GL_COMBINER3_NV                                                 0x8553
#endif //GL_COMBINER3_NV
#ifndef GL_COMBINER4_NV
#define GL_COMBINER4_NV                                                 0x8554
#endif //GL_COMBINER4_NV
#ifndef GL_COMBINER5_NV
#define GL_COMBINER5_NV                                                 0x8555
#endif //GL_COMBINER5_NV
#ifndef GL_COMBINER6_NV
#define GL_COMBINER6_NV                                                 0x8556
#endif //GL_COMBINER6_NV
#ifndef GL_COMBINER7_NV
#define GL_COMBINER7_NV                                                 0x8557
#endif //GL_COMBINER7_NV

#endif //GL_NV_register_combiners


typedef void (*PFNCOMBINERPARAMETERFVNVPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void CombinerParameterfvNV(GLenum pname,const GLfloat *params)
{
	static PFNCOMBINERPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNCOMBINERPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glCombinerParameterfvNV","GL_NV_register_combiners"));
	 fn(pname,params);
}

typedef void (*PFNCOMBINERPARAMETERFNVPROC_HPP)(GLenum pname,GLfloat param);

static inline void CombinerParameterfNV(GLenum pname,GLfloat param)
{
	static PFNCOMBINERPARAMETERFNVPROC_HPP fn=reinterpret_cast<PFNCOMBINERPARAMETERFNVPROC_HPP>(_impl::_get_proc_address("glCombinerParameterfNV","GL_NV_register_combiners"));
	 fn(pname,param);
}

typedef void (*PFNCOMBINERPARAMETERIVNVPROC_HPP)(GLenum pname,const GLint *params);

static inline void CombinerParameterivNV(GLenum pname,const GLint *params)
{
	static PFNCOMBINERPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNCOMBINERPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glCombinerParameterivNV","GL_NV_register_combiners"));
	 fn(pname,params);
}

typedef void (*PFNCOMBINERPARAMETERINVPROC_HPP)(GLenum pname,GLint param);

static inline void CombinerParameteriNV(GLenum pname,GLint param)
{
	static PFNCOMBINERPARAMETERINVPROC_HPP fn=reinterpret_cast<PFNCOMBINERPARAMETERINVPROC_HPP>(_impl::_get_proc_address("glCombinerParameteriNV","GL_NV_register_combiners"));
	 fn(pname,param);
}

typedef void (*PFNCOMBINERINPUTNVPROC_HPP)(GLenum stage,GLenum portion,GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);

static inline void CombinerInputNV(GLenum stage,GLenum portion,GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage)
{
	static PFNCOMBINERINPUTNVPROC_HPP fn=reinterpret_cast<PFNCOMBINERINPUTNVPROC_HPP>(_impl::_get_proc_address("glCombinerInputNV","GL_NV_register_combiners"));
	 fn(stage,portion,variable,input,mapping,componentUsage);
}

typedef void (*PFNCOMBINEROUTPUTNVPROC_HPP)(GLenum stage,GLenum portion,GLenum abOutput,GLenum cdOutput,GLenum sumOutput,GLenum scale,GLenum bias,GLboolean abDotProduct,GLboolean cdDotProduct,GLboolean muxSum);

static inline void CombinerOutputNV(GLenum stage,GLenum portion,GLenum abOutput,GLenum cdOutput,GLenum sumOutput,GLenum scale,GLenum bias,GLboolean abDotProduct,GLboolean cdDotProduct,GLboolean muxSum)
{
	static PFNCOMBINEROUTPUTNVPROC_HPP fn=reinterpret_cast<PFNCOMBINEROUTPUTNVPROC_HPP>(_impl::_get_proc_address("glCombinerOutputNV","GL_NV_register_combiners"));
	 fn(stage,portion,abOutput,cdOutput,sumOutput,scale,bias,abDotProduct,cdDotProduct,muxSum);
}

typedef void (*PFNFINALCOMBINERINPUTNVPROC_HPP)(GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);

static inline void FinalCombinerInputNV(GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage)
{
	static PFNFINALCOMBINERINPUTNVPROC_HPP fn=reinterpret_cast<PFNFINALCOMBINERINPUTNVPROC_HPP>(_impl::_get_proc_address("glFinalCombinerInputNV","GL_NV_register_combiners"));
	 fn(variable,input,mapping,componentUsage);
}

typedef void (*PFNGETCOMBINERINPUTPARAMETERFVNVPROC_HPP)(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLfloat *params);

static inline void GetCombinerInputParameterfvNV(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLfloat *params)
{
	static PFNGETCOMBINERINPUTPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETCOMBINERINPUTPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetCombinerInputParameterfvNV","GL_NV_register_combiners"));
	 fn(stage,portion,variable,pname,params);
}

typedef void (*PFNGETCOMBINERINPUTPARAMETERIVNVPROC_HPP)(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLint *params);

static inline void GetCombinerInputParameterivNV(GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLint *params)
{
	static PFNGETCOMBINERINPUTPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETCOMBINERINPUTPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetCombinerInputParameterivNV","GL_NV_register_combiners"));
	 fn(stage,portion,variable,pname,params);
}

typedef void (*PFNGETCOMBINEROUTPUTPARAMETERFVNVPROC_HPP)(GLenum stage,GLenum portion,GLenum pname,GLfloat *params);

static inline void GetCombinerOutputParameterfvNV(GLenum stage,GLenum portion,GLenum pname,GLfloat *params)
{
	static PFNGETCOMBINEROUTPUTPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETCOMBINEROUTPUTPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetCombinerOutputParameterfvNV","GL_NV_register_combiners"));
	 fn(stage,portion,pname,params);
}

typedef void (*PFNGETCOMBINEROUTPUTPARAMETERIVNVPROC_HPP)(GLenum stage,GLenum portion,GLenum pname,GLint *params);

static inline void GetCombinerOutputParameterivNV(GLenum stage,GLenum portion,GLenum pname,GLint *params)
{
	static PFNGETCOMBINEROUTPUTPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETCOMBINEROUTPUTPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetCombinerOutputParameterivNV","GL_NV_register_combiners"));
	 fn(stage,portion,pname,params);
}

typedef void (*PFNGETFINALCOMBINERINPUTPARAMETERFVNVPROC_HPP)(GLenum variable,GLenum pname,GLfloat *params);

static inline void GetFinalCombinerInputParameterfvNV(GLenum variable,GLenum pname,GLfloat *params)
{
	static PFNGETFINALCOMBINERINPUTPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETFINALCOMBINERINPUTPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetFinalCombinerInputParameterfvNV","GL_NV_register_combiners"));
	 fn(variable,pname,params);
}

typedef void (*PFNGETFINALCOMBINERINPUTPARAMETERIVNVPROC_HPP)(GLenum variable,GLenum pname,GLint *params);

static inline void GetFinalCombinerInputParameterivNV(GLenum variable,GLenum pname,GLint *params)
{
	static PFNGETFINALCOMBINERINPUTPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNGETFINALCOMBINERINPUTPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glGetFinalCombinerInputParameterivNV","GL_NV_register_combiners"));
	 fn(variable,pname,params);
}
#ifndef GL_NV_register_combiners2

#define GL_NV_register_combiners2
#ifndef GL_PER_STAGE_CONSTANTS_NV
#define GL_PER_STAGE_CONSTANTS_NV                                       0x8535
#endif //GL_PER_STAGE_CONSTANTS_NV

#endif //GL_NV_register_combiners2


typedef void (*PFNCOMBINERSTAGEPARAMETERFVNVPROC_HPP)(GLenum stage,GLenum pname,const GLfloat *params);

static inline void CombinerStageParameterfvNV(GLenum stage,GLenum pname,const GLfloat *params)
{
	static PFNCOMBINERSTAGEPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNCOMBINERSTAGEPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glCombinerStageParameterfvNV","GL_NV_register_combiners2"));
	 fn(stage,pname,params);
}

typedef void (*PFNGETCOMBINERSTAGEPARAMETERFVNVPROC_HPP)(GLenum stage,GLenum pname,GLfloat *params);

static inline void GetCombinerStageParameterfvNV(GLenum stage,GLenum pname,GLfloat *params)
{
	static PFNGETCOMBINERSTAGEPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETCOMBINERSTAGEPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetCombinerStageParameterfvNV","GL_NV_register_combiners2"));
	 fn(stage,pname,params);
}
#ifndef GL_NV_shader_buffer_load

#define GL_NV_shader_buffer_load
#ifndef GL_BUFFER_GPU_ADDRESS_NV
#define GL_BUFFER_GPU_ADDRESS_NV                                        0x8F1D
#endif //GL_BUFFER_GPU_ADDRESS_NV
#ifndef GL_GPU_ADDRESS_NV
#define GL_GPU_ADDRESS_NV                                               0x8F34
#endif //GL_GPU_ADDRESS_NV
#ifndef GL_MAX_SHADER_BUFFER_ADDRESS_NV
#define GL_MAX_SHADER_BUFFER_ADDRESS_NV                                 0x8F35
#endif //GL_MAX_SHADER_BUFFER_ADDRESS_NV

#endif //GL_NV_shader_buffer_load


typedef void (*PFNMAKEBUFFERRESIDENTNVPROC_HPP)(GLenum target,GLenum access);

static inline void MakeBufferResidentNV(GLenum target,GLenum access)
{
	static PFNMAKEBUFFERRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKEBUFFERRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeBufferResidentNV","GL_NV_shader_buffer_load"));
	 fn(target,access);
}

typedef void (*PFNMAKEBUFFERNONRESIDENTNVPROC_HPP)(GLenum target);

static inline void MakeBufferNonResidentNV(GLenum target)
{
	static PFNMAKEBUFFERNONRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKEBUFFERNONRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeBufferNonResidentNV","GL_NV_shader_buffer_load"));
	 fn(target);
}

typedef GLboolean (*PFNISBUFFERRESIDENTNVPROC_HPP)(GLenum target);

static inline GLboolean IsBufferResidentNV(GLenum target)
{
	static PFNISBUFFERRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNISBUFFERRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glIsBufferResidentNV","GL_NV_shader_buffer_load"));
	return fn(target);
}

typedef void (*PFNMAKENAMEDBUFFERRESIDENTNVPROC_HPP)(GLuint buffer,GLenum access);

static inline void MakeNamedBufferResidentNV(GLuint buffer,GLenum access)
{
	static PFNMAKENAMEDBUFFERRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKENAMEDBUFFERRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeNamedBufferResidentNV","GL_NV_shader_buffer_load"));
	 fn(buffer,access);
}

typedef void (*PFNMAKENAMEDBUFFERNONRESIDENTNVPROC_HPP)(GLuint buffer);

static inline void MakeNamedBufferNonResidentNV(GLuint buffer)
{
	static PFNMAKENAMEDBUFFERNONRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNMAKENAMEDBUFFERNONRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glMakeNamedBufferNonResidentNV","GL_NV_shader_buffer_load"));
	 fn(buffer);
}

typedef GLboolean (*PFNISNAMEDBUFFERRESIDENTNVPROC_HPP)(GLuint buffer);

static inline GLboolean IsNamedBufferResidentNV(GLuint buffer)
{
	static PFNISNAMEDBUFFERRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNISNAMEDBUFFERRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glIsNamedBufferResidentNV","GL_NV_shader_buffer_load"));
	return fn(buffer);
}

typedef void (*PFNGETBUFFERPARAMETERUI64VNVPROC_HPP)(GLenum target,GLenum pname,GLuint64EXT *params);

static inline void GetBufferParameterui64vNV(GLenum target,GLenum pname,GLuint64EXT *params)
{
	static PFNGETBUFFERPARAMETERUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETBUFFERPARAMETERUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetBufferParameterui64vNV","GL_NV_shader_buffer_load"));
	 fn(target,pname,params);
}

typedef void (*PFNGETNAMEDBUFFERPARAMETERUI64VNVPROC_HPP)(GLuint buffer,GLenum pname,GLuint64EXT *params);

static inline void GetNamedBufferParameterui64vNV(GLuint buffer,GLenum pname,GLuint64EXT *params)
{
	static PFNGETNAMEDBUFFERPARAMETERUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETNAMEDBUFFERPARAMETERUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetNamedBufferParameterui64vNV","GL_NV_shader_buffer_load"));
	 fn(buffer,pname,params);
}

typedef void (*PFNGETINTEGERUI64VNVPROC_HPP)(GLenum value,GLuint64EXT *result);

static inline void GetIntegerui64vNV(GLenum value,GLuint64EXT *result)
{
	static PFNGETINTEGERUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETINTEGERUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetIntegerui64vNV","GL_NV_shader_buffer_load"));
	 fn(value,result);
}

typedef void (*PFNUNIFORMUI64NVPROC_HPP)(GLint location,GLuint64EXT value);

static inline void Uniformui64NV(GLint location,GLuint64EXT value)
{
	static PFNUNIFORMUI64NVPROC_HPP fn=reinterpret_cast<PFNUNIFORMUI64NVPROC_HPP>(_impl::_get_proc_address("glUniformui64NV","GL_NV_shader_buffer_load"));
	 fn(location,value);
}

typedef void (*PFNUNIFORMUI64VNVPROC_HPP)(GLint location,GLsizei count,const GLuint64EXT *value);

static inline void Uniformui64vNV(GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNUNIFORMUI64VNVPROC_HPP fn=reinterpret_cast<PFNUNIFORMUI64VNVPROC_HPP>(_impl::_get_proc_address("glUniformui64vNV","GL_NV_shader_buffer_load"));
	 fn(location,count,value);
}

typedef void (*PFNGETUNIFORMUI64VNVPROC_HPP)(GLuint program,GLint location,GLuint64EXT *params);

static inline void GetUniformui64vNV(GLuint program,GLint location,GLuint64EXT *params)
{
	static PFNGETUNIFORMUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETUNIFORMUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetUniformui64vNV","GL_NV_shader_buffer_load"));
	 fn(program,location,params);
}

typedef void (*PFNPROGRAMUNIFORMUI64NVPROC_HPP)(GLuint program,GLint location,GLuint64EXT value);

static inline void ProgramUniformui64NV(GLuint program,GLint location,GLuint64EXT value)
{
	static PFNPROGRAMUNIFORMUI64NVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMUI64NVPROC_HPP>(_impl::_get_proc_address("glProgramUniformui64NV","GL_NV_shader_buffer_load"));
	 fn(program,location,value);
}

typedef void (*PFNPROGRAMUNIFORMUI64VNVPROC_HPP)(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value);

static inline void ProgramUniformui64vNV(GLuint program,GLint location,GLsizei count,const GLuint64EXT *value)
{
	static PFNPROGRAMUNIFORMUI64VNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMUNIFORMUI64VNVPROC_HPP>(_impl::_get_proc_address("glProgramUniformui64vNV","GL_NV_shader_buffer_load"));
	 fn(program,location,count,value);
}
#ifndef GL_NV_shader_buffer_store

#define GL_NV_shader_buffer_store
#ifndef GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV
#define GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV                          0x00000010
#endif //GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV

#endif //GL_NV_shader_buffer_store

#ifndef GL_NV_tessellation_program5

#define GL_NV_tessellation_program5
#ifndef GL_MAX_PROGRAM_PATCH_ATTRIBS_NV
#define GL_MAX_PROGRAM_PATCH_ATTRIBS_NV                                 0x86D8
#endif //GL_MAX_PROGRAM_PATCH_ATTRIBS_NV
#ifndef GL_TESS_CONTROL_PROGRAM_NV
#define GL_TESS_CONTROL_PROGRAM_NV                                      0x891E
#endif //GL_TESS_CONTROL_PROGRAM_NV
#ifndef GL_TESS_EVALUATION_PROGRAM_NV
#define GL_TESS_EVALUATION_PROGRAM_NV                                   0x891F
#endif //GL_TESS_EVALUATION_PROGRAM_NV
#ifndef GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV
#define GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV                     0x8C74
#endif //GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV
#ifndef GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV
#define GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV                  0x8C75
#endif //GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV

#endif //GL_NV_tessellation_program5

#ifndef GL_NV_texgen_emboss

#define GL_NV_texgen_emboss
#ifndef GL_EMBOSS_LIGHT_NV
#define GL_EMBOSS_LIGHT_NV                                              0x855D
#endif //GL_EMBOSS_LIGHT_NV
#ifndef GL_EMBOSS_CONSTANT_NV
#define GL_EMBOSS_CONSTANT_NV                                           0x855E
#endif //GL_EMBOSS_CONSTANT_NV
#ifndef GL_EMBOSS_MAP_NV
#define GL_EMBOSS_MAP_NV                                                0x855F
#endif //GL_EMBOSS_MAP_NV

#endif //GL_NV_texgen_emboss

#ifndef GL_NV_texgen_reflection

#define GL_NV_texgen_reflection

#endif //GL_NV_texgen_reflection

#ifndef GL_NV_texture_barrier

#define GL_NV_texture_barrier

#endif //GL_NV_texture_barrier


typedef void (*PFNTEXTUREBARRIERNVPROC_HPP)();

static inline void TextureBarrierNV()
{
	static PFNTEXTUREBARRIERNVPROC_HPP fn=reinterpret_cast<PFNTEXTUREBARRIERNVPROC_HPP>(_impl::_get_proc_address("glTextureBarrierNV","GL_NV_texture_barrier"));
	 fn();
}
#ifndef GL_NV_texture_env_combine4

#define GL_NV_texture_env_combine4
#ifndef GL_COMBINE4_NV
#define GL_COMBINE4_NV                                                  0x8503
#endif //GL_COMBINE4_NV
#ifndef GL_SOURCE3_RGB_NV
#define GL_SOURCE3_RGB_NV                                               0x8583
#endif //GL_SOURCE3_RGB_NV
#ifndef GL_SOURCE3_ALPHA_NV
#define GL_SOURCE3_ALPHA_NV                                             0x858B
#endif //GL_SOURCE3_ALPHA_NV
#ifndef GL_OPERAND3_RGB_NV
#define GL_OPERAND3_RGB_NV                                              0x8593
#endif //GL_OPERAND3_RGB_NV
#ifndef GL_OPERAND3_ALPHA_NV
#define GL_OPERAND3_ALPHA_NV                                            0x859B
#endif //GL_OPERAND3_ALPHA_NV

#endif //GL_NV_texture_env_combine4

#ifndef GL_NV_texture_expand_normal

#define GL_NV_texture_expand_normal
#ifndef GL_TEXTURE_UNSIGNED_REMAP_MODE_NV
#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV                               0x888F
#endif //GL_TEXTURE_UNSIGNED_REMAP_MODE_NV

#endif //GL_NV_texture_expand_normal

#ifndef GL_NV_texture_multisample

#define GL_NV_texture_multisample
#ifndef GL_TEXTURE_COVERAGE_SAMPLES_NV
#define GL_TEXTURE_COVERAGE_SAMPLES_NV                                  0x9045
#endif //GL_TEXTURE_COVERAGE_SAMPLES_NV
#ifndef GL_TEXTURE_COLOR_SAMPLES_NV
#define GL_TEXTURE_COLOR_SAMPLES_NV                                     0x9046
#endif //GL_TEXTURE_COLOR_SAMPLES_NV

#endif //GL_NV_texture_multisample


typedef void (*PFNTEXIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP)(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);

static inline void TexImage2DMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations)
{
	static PFNTEXIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP>(_impl::_get_proc_address("glTexImage2DMultisampleCoverageNV","GL_NV_texture_multisample"));
	 fn(target,coverageSamples,colorSamples,internalFormat,width,height,fixedSampleLocations);
}

typedef void (*PFNTEXIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP)(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);

static inline void TexImage3DMultisampleCoverageNV(GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations)
{
	static PFNTEXIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP>(_impl::_get_proc_address("glTexImage3DMultisampleCoverageNV","GL_NV_texture_multisample"));
	 fn(target,coverageSamples,colorSamples,internalFormat,width,height,depth,fixedSampleLocations);
}

typedef void (*PFNTEXTUREIMAGE2DMULTISAMPLENVPROC_HPP)(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);

static inline void TextureImage2DMultisampleNV(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations)
{
	static PFNTEXTUREIMAGE2DMULTISAMPLENVPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE2DMULTISAMPLENVPROC_HPP>(_impl::_get_proc_address("glTextureImage2DMultisampleNV","GL_NV_texture_multisample"));
	 fn(texture,target,samples,internalFormat,width,height,fixedSampleLocations);
}

typedef void (*PFNTEXTUREIMAGE3DMULTISAMPLENVPROC_HPP)(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);

static inline void TextureImage3DMultisampleNV(GLuint texture,GLenum target,GLsizei samples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations)
{
	static PFNTEXTUREIMAGE3DMULTISAMPLENVPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE3DMULTISAMPLENVPROC_HPP>(_impl::_get_proc_address("glTextureImage3DMultisampleNV","GL_NV_texture_multisample"));
	 fn(texture,target,samples,internalFormat,width,height,depth,fixedSampleLocations);
}

typedef void (*PFNTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP)(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations);

static inline void TextureImage2DMultisampleCoverageNV(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLboolean fixedSampleLocations)
{
	static PFNTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE2DMULTISAMPLECOVERAGENVPROC_HPP>(_impl::_get_proc_address("glTextureImage2DMultisampleCoverageNV","GL_NV_texture_multisample"));
	 fn(texture,target,coverageSamples,colorSamples,internalFormat,width,height,fixedSampleLocations);
}

typedef void (*PFNTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP)(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations);

static inline void TextureImage3DMultisampleCoverageNV(GLuint texture,GLenum target,GLsizei coverageSamples,GLsizei colorSamples,GLint internalFormat,GLsizei width,GLsizei height,GLsizei depth,GLboolean fixedSampleLocations)
{
	static PFNTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP fn=reinterpret_cast<PFNTEXTUREIMAGE3DMULTISAMPLECOVERAGENVPROC_HPP>(_impl::_get_proc_address("glTextureImage3DMultisampleCoverageNV","GL_NV_texture_multisample"));
	 fn(texture,target,coverageSamples,colorSamples,internalFormat,width,height,depth,fixedSampleLocations);
}
#ifndef GL_NV_texture_rectangle

#define GL_NV_texture_rectangle
#ifndef GL_TEXTURE_RECTANGLE_NV
#define GL_TEXTURE_RECTANGLE_NV                                         0x84F5
#endif //GL_TEXTURE_RECTANGLE_NV
#ifndef GL_TEXTURE_BINDING_RECTANGLE_NV
#define GL_TEXTURE_BINDING_RECTANGLE_NV                                 0x84F6
#endif //GL_TEXTURE_BINDING_RECTANGLE_NV
#ifndef GL_PROXY_TEXTURE_RECTANGLE_NV
#define GL_PROXY_TEXTURE_RECTANGLE_NV                                   0x84F7
#endif //GL_PROXY_TEXTURE_RECTANGLE_NV
#ifndef GL_MAX_RECTANGLE_TEXTURE_SIZE_NV
#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV                                0x84F8
#endif //GL_MAX_RECTANGLE_TEXTURE_SIZE_NV

#endif //GL_NV_texture_rectangle

#ifndef GL_NV_texture_shader

#define GL_NV_texture_shader
#ifndef GL_OFFSET_TEXTURE_RECTANGLE_NV
#define GL_OFFSET_TEXTURE_RECTANGLE_NV                                  0x864C
#endif //GL_OFFSET_TEXTURE_RECTANGLE_NV
#ifndef GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV
#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV                            0x864D
#endif //GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV
#ifndef GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV
#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV                             0x864E
#endif //GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV
#ifndef GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV
#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV                         0x86D9
#endif //GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV
#ifndef GL_UNSIGNED_INT_S8_S8_8_8_NV
#define GL_UNSIGNED_INT_S8_S8_8_8_NV                                    0x86DA
#endif //GL_UNSIGNED_INT_S8_S8_8_8_NV
#ifndef GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV                                0x86DB
#endif //GL_UNSIGNED_INT_8_8_S8_S8_REV_NV
#ifndef GL_DSDT_MAG_INTENSITY_NV
#define GL_DSDT_MAG_INTENSITY_NV                                        0x86DC
#endif //GL_DSDT_MAG_INTENSITY_NV
#ifndef GL_SHADER_CONSISTENT_NV
#define GL_SHADER_CONSISTENT_NV                                         0x86DD
#endif //GL_SHADER_CONSISTENT_NV
#ifndef GL_TEXTURE_SHADER_NV
#define GL_TEXTURE_SHADER_NV                                            0x86DE
#endif //GL_TEXTURE_SHADER_NV
#ifndef GL_SHADER_OPERATION_NV
#define GL_SHADER_OPERATION_NV                                          0x86DF
#endif //GL_SHADER_OPERATION_NV
#ifndef GL_CULL_MODES_NV
#define GL_CULL_MODES_NV                                                0x86E0
#endif //GL_CULL_MODES_NV
#ifndef GL_OFFSET_TEXTURE_2D_MATRIX_NV
#define GL_OFFSET_TEXTURE_2D_MATRIX_NV                                  0x86E1
#endif //GL_OFFSET_TEXTURE_2D_MATRIX_NV
#ifndef GL_OFFSET_TEXTURE_MATRIX_NV
#define GL_OFFSET_TEXTURE_MATRIX_NV                                     0x86E1
#endif //GL_OFFSET_TEXTURE_MATRIX_NV
#ifndef GL_OFFSET_TEXTURE_2D_SCALE_NV
#define GL_OFFSET_TEXTURE_2D_SCALE_NV                                   0x86E2
#endif //GL_OFFSET_TEXTURE_2D_SCALE_NV
#ifndef GL_OFFSET_TEXTURE_SCALE_NV
#define GL_OFFSET_TEXTURE_SCALE_NV                                      0x86E2
#endif //GL_OFFSET_TEXTURE_SCALE_NV
#ifndef GL_OFFSET_TEXTURE_2D_BIAS_NV
#define GL_OFFSET_TEXTURE_2D_BIAS_NV                                    0x86E3
#endif //GL_OFFSET_TEXTURE_2D_BIAS_NV
#ifndef GL_OFFSET_TEXTURE_BIAS_NV
#define GL_OFFSET_TEXTURE_BIAS_NV                                       0x86E3
#endif //GL_OFFSET_TEXTURE_BIAS_NV
#ifndef GL_PREVIOUS_TEXTURE_INPUT_NV
#define GL_PREVIOUS_TEXTURE_INPUT_NV                                    0x86E4
#endif //GL_PREVIOUS_TEXTURE_INPUT_NV
#ifndef GL_CONST_EYE_NV
#define GL_CONST_EYE_NV                                                 0x86E5
#endif //GL_CONST_EYE_NV
#ifndef GL_PASS_THROUGH_NV
#define GL_PASS_THROUGH_NV                                              0x86E6
#endif //GL_PASS_THROUGH_NV
#ifndef GL_CULL_FRAGMENT_NV
#define GL_CULL_FRAGMENT_NV                                             0x86E7
#endif //GL_CULL_FRAGMENT_NV
#ifndef GL_OFFSET_TEXTURE_2D_NV
#define GL_OFFSET_TEXTURE_2D_NV                                         0x86E8
#endif //GL_OFFSET_TEXTURE_2D_NV
#ifndef GL_DEPENDENT_AR_TEXTURE_2D_NV
#define GL_DEPENDENT_AR_TEXTURE_2D_NV                                   0x86E9
#endif //GL_DEPENDENT_AR_TEXTURE_2D_NV
#ifndef GL_DEPENDENT_GB_TEXTURE_2D_NV
#define GL_DEPENDENT_GB_TEXTURE_2D_NV                                   0x86EA
#endif //GL_DEPENDENT_GB_TEXTURE_2D_NV
#ifndef GL_DOT_PRODUCT_NV
#define GL_DOT_PRODUCT_NV                                               0x86EC
#endif //GL_DOT_PRODUCT_NV
#ifndef GL_DOT_PRODUCT_DEPTH_REPLACE_NV
#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV                                 0x86ED
#endif //GL_DOT_PRODUCT_DEPTH_REPLACE_NV
#ifndef GL_DOT_PRODUCT_TEXTURE_2D_NV
#define GL_DOT_PRODUCT_TEXTURE_2D_NV                                    0x86EE
#endif //GL_DOT_PRODUCT_TEXTURE_2D_NV
#ifndef GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV
#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV                              0x86F0
#endif //GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV
#ifndef GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV                              0x86F1
#endif //GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV
#ifndef GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV                              0x86F2
#endif //GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV
#ifndef GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV
#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV                    0x86F3
#endif //GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV
#ifndef GL_HILO_NV
#define GL_HILO_NV                                                      0x86F4
#endif //GL_HILO_NV
#ifndef GL_DSDT_NV
#define GL_DSDT_NV                                                      0x86F5
#endif //GL_DSDT_NV
#ifndef GL_DSDT_MAG_NV
#define GL_DSDT_MAG_NV                                                  0x86F6
#endif //GL_DSDT_MAG_NV
#ifndef GL_DSDT_MAG_VIB_NV
#define GL_DSDT_MAG_VIB_NV                                              0x86F7
#endif //GL_DSDT_MAG_VIB_NV
#ifndef GL_HILO16_NV
#define GL_HILO16_NV                                                    0x86F8
#endif //GL_HILO16_NV
#ifndef GL_SIGNED_HILO_NV
#define GL_SIGNED_HILO_NV                                               0x86F9
#endif //GL_SIGNED_HILO_NV
#ifndef GL_SIGNED_HILO16_NV
#define GL_SIGNED_HILO16_NV                                             0x86FA
#endif //GL_SIGNED_HILO16_NV
#ifndef GL_SIGNED_RGBA_NV
#define GL_SIGNED_RGBA_NV                                               0x86FB
#endif //GL_SIGNED_RGBA_NV
#ifndef GL_SIGNED_RGBA8_NV
#define GL_SIGNED_RGBA8_NV                                              0x86FC
#endif //GL_SIGNED_RGBA8_NV
#ifndef GL_SIGNED_RGB_NV
#define GL_SIGNED_RGB_NV                                                0x86FE
#endif //GL_SIGNED_RGB_NV
#ifndef GL_SIGNED_RGB8_NV
#define GL_SIGNED_RGB8_NV                                               0x86FF
#endif //GL_SIGNED_RGB8_NV
#ifndef GL_SIGNED_LUMINANCE_NV
#define GL_SIGNED_LUMINANCE_NV                                          0x8701
#endif //GL_SIGNED_LUMINANCE_NV
#ifndef GL_SIGNED_LUMINANCE8_NV
#define GL_SIGNED_LUMINANCE8_NV                                         0x8702
#endif //GL_SIGNED_LUMINANCE8_NV
#ifndef GL_SIGNED_LUMINANCE_ALPHA_NV
#define GL_SIGNED_LUMINANCE_ALPHA_NV                                    0x8703
#endif //GL_SIGNED_LUMINANCE_ALPHA_NV
#ifndef GL_SIGNED_LUMINANCE8_ALPHA8_NV
#define GL_SIGNED_LUMINANCE8_ALPHA8_NV                                  0x8704
#endif //GL_SIGNED_LUMINANCE8_ALPHA8_NV
#ifndef GL_SIGNED_ALPHA_NV
#define GL_SIGNED_ALPHA_NV                                              0x8705
#endif //GL_SIGNED_ALPHA_NV
#ifndef GL_SIGNED_ALPHA8_NV
#define GL_SIGNED_ALPHA8_NV                                             0x8706
#endif //GL_SIGNED_ALPHA8_NV
#ifndef GL_SIGNED_INTENSITY_NV
#define GL_SIGNED_INTENSITY_NV                                          0x8707
#endif //GL_SIGNED_INTENSITY_NV
#ifndef GL_SIGNED_INTENSITY8_NV
#define GL_SIGNED_INTENSITY8_NV                                         0x8708
#endif //GL_SIGNED_INTENSITY8_NV
#ifndef GL_DSDT8_NV
#define GL_DSDT8_NV                                                     0x8709
#endif //GL_DSDT8_NV
#ifndef GL_DSDT8_MAG8_NV
#define GL_DSDT8_MAG8_NV                                                0x870A
#endif //GL_DSDT8_MAG8_NV
#ifndef GL_DSDT8_MAG8_INTENSITY8_NV
#define GL_DSDT8_MAG8_INTENSITY8_NV                                     0x870B
#endif //GL_DSDT8_MAG8_INTENSITY8_NV
#ifndef GL_SIGNED_RGB_UNSIGNED_ALPHA_NV
#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV                                 0x870C
#endif //GL_SIGNED_RGB_UNSIGNED_ALPHA_NV
#ifndef GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV
#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV                               0x870D
#endif //GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV
#ifndef GL_HI_SCALE_NV
#define GL_HI_SCALE_NV                                                  0x870E
#endif //GL_HI_SCALE_NV
#ifndef GL_LO_SCALE_NV
#define GL_LO_SCALE_NV                                                  0x870F
#endif //GL_LO_SCALE_NV
#ifndef GL_DS_SCALE_NV
#define GL_DS_SCALE_NV                                                  0x8710
#endif //GL_DS_SCALE_NV
#ifndef GL_DT_SCALE_NV
#define GL_DT_SCALE_NV                                                  0x8711
#endif //GL_DT_SCALE_NV
#ifndef GL_MAGNITUDE_SCALE_NV
#define GL_MAGNITUDE_SCALE_NV                                           0x8712
#endif //GL_MAGNITUDE_SCALE_NV
#ifndef GL_VIBRANCE_SCALE_NV
#define GL_VIBRANCE_SCALE_NV                                            0x8713
#endif //GL_VIBRANCE_SCALE_NV
#ifndef GL_HI_BIAS_NV
#define GL_HI_BIAS_NV                                                   0x8714
#endif //GL_HI_BIAS_NV
#ifndef GL_LO_BIAS_NV
#define GL_LO_BIAS_NV                                                   0x8715
#endif //GL_LO_BIAS_NV
#ifndef GL_DS_BIAS_NV
#define GL_DS_BIAS_NV                                                   0x8716
#endif //GL_DS_BIAS_NV
#ifndef GL_DT_BIAS_NV
#define GL_DT_BIAS_NV                                                   0x8717
#endif //GL_DT_BIAS_NV
#ifndef GL_MAGNITUDE_BIAS_NV
#define GL_MAGNITUDE_BIAS_NV                                            0x8718
#endif //GL_MAGNITUDE_BIAS_NV
#ifndef GL_VIBRANCE_BIAS_NV
#define GL_VIBRANCE_BIAS_NV                                             0x8719
#endif //GL_VIBRANCE_BIAS_NV
#ifndef GL_TEXTURE_BORDER_VALUES_NV
#define GL_TEXTURE_BORDER_VALUES_NV                                     0x871A
#endif //GL_TEXTURE_BORDER_VALUES_NV
#ifndef GL_TEXTURE_HI_SIZE_NV
#define GL_TEXTURE_HI_SIZE_NV                                           0x871B
#endif //GL_TEXTURE_HI_SIZE_NV
#ifndef GL_TEXTURE_LO_SIZE_NV
#define GL_TEXTURE_LO_SIZE_NV                                           0x871C
#endif //GL_TEXTURE_LO_SIZE_NV
#ifndef GL_TEXTURE_DS_SIZE_NV
#define GL_TEXTURE_DS_SIZE_NV                                           0x871D
#endif //GL_TEXTURE_DS_SIZE_NV
#ifndef GL_TEXTURE_DT_SIZE_NV
#define GL_TEXTURE_DT_SIZE_NV                                           0x871E
#endif //GL_TEXTURE_DT_SIZE_NV
#ifndef GL_TEXTURE_MAG_SIZE_NV
#define GL_TEXTURE_MAG_SIZE_NV                                          0x871F
#endif //GL_TEXTURE_MAG_SIZE_NV

#endif //GL_NV_texture_shader

#ifndef GL_NV_texture_shader2

#define GL_NV_texture_shader2
#ifndef GL_DOT_PRODUCT_TEXTURE_3D_NV
#define GL_DOT_PRODUCT_TEXTURE_3D_NV                                    0x86EF
#endif //GL_DOT_PRODUCT_TEXTURE_3D_NV

#endif //GL_NV_texture_shader2

#ifndef GL_NV_texture_shader3

#define GL_NV_texture_shader3
#ifndef GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV
#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV                              0x8850
#endif //GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV
#ifndef GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV
#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV                        0x8851
#endif //GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV
#ifndef GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV
#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV                       0x8852
#endif //GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV
#ifndef GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV
#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV                 0x8853
#endif //GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV
#ifndef GL_OFFSET_HILO_TEXTURE_2D_NV
#define GL_OFFSET_HILO_TEXTURE_2D_NV                                    0x8854
#endif //GL_OFFSET_HILO_TEXTURE_2D_NV
#ifndef GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV
#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV                             0x8855
#endif //GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV
#ifndef GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV
#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV                         0x8856
#endif //GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV
#ifndef GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV
#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV                  0x8857
#endif //GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV
#ifndef GL_DEPENDENT_HILO_TEXTURE_2D_NV
#define GL_DEPENDENT_HILO_TEXTURE_2D_NV                                 0x8858
#endif //GL_DEPENDENT_HILO_TEXTURE_2D_NV
#ifndef GL_DEPENDENT_RGB_TEXTURE_3D_NV
#define GL_DEPENDENT_RGB_TEXTURE_3D_NV                                  0x8859
#endif //GL_DEPENDENT_RGB_TEXTURE_3D_NV
#ifndef GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV
#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV                            0x885A
#endif //GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV
#ifndef GL_DOT_PRODUCT_PASS_THROUGH_NV
#define GL_DOT_PRODUCT_PASS_THROUGH_NV                                  0x885B
#endif //GL_DOT_PRODUCT_PASS_THROUGH_NV
#ifndef GL_DOT_PRODUCT_TEXTURE_1D_NV
#define GL_DOT_PRODUCT_TEXTURE_1D_NV                                    0x885C
#endif //GL_DOT_PRODUCT_TEXTURE_1D_NV
#ifndef GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV
#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV                          0x885D
#endif //GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV
#ifndef GL_HILO8_NV
#define GL_HILO8_NV                                                     0x885E
#endif //GL_HILO8_NV
#ifndef GL_SIGNED_HILO8_NV
#define GL_SIGNED_HILO8_NV                                              0x885F
#endif //GL_SIGNED_HILO8_NV
#ifndef GL_FORCE_BLUE_TO_ONE_NV
#define GL_FORCE_BLUE_TO_ONE_NV                                         0x8860
#endif //GL_FORCE_BLUE_TO_ONE_NV

#endif //GL_NV_texture_shader3

#ifndef GL_NV_transform_feedback

#define GL_NV_transform_feedback
#ifndef GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH                        0x8C76
#endif //GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
#ifndef GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT
#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT                    0x8C76
#endif //GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT
#ifndef GL_BACK_PRIMARY_COLOR_NV
#define GL_BACK_PRIMARY_COLOR_NV                                        0x8C77
#endif //GL_BACK_PRIMARY_COLOR_NV
#ifndef GL_BACK_SECONDARY_COLOR_NV
#define GL_BACK_SECONDARY_COLOR_NV                                      0x8C78
#endif //GL_BACK_SECONDARY_COLOR_NV
#ifndef GL_TEXTURE_COORD_NV
#define GL_TEXTURE_COORD_NV                                             0x8C79
#endif //GL_TEXTURE_COORD_NV
#ifndef GL_CLIP_DISTANCE_NV
#define GL_CLIP_DISTANCE_NV                                             0x8C7A
#endif //GL_CLIP_DISTANCE_NV
#ifndef GL_VERTEX_ID_NV
#define GL_VERTEX_ID_NV                                                 0x8C7B
#endif //GL_VERTEX_ID_NV
#ifndef GL_PRIMITIVE_ID_NV
#define GL_PRIMITIVE_ID_NV                                              0x8C7C
#endif //GL_PRIMITIVE_ID_NV
#ifndef GL_GENERIC_ATTRIB_NV
#define GL_GENERIC_ATTRIB_NV                                            0x8C7D
#endif //GL_GENERIC_ATTRIB_NV
#ifndef GL_TRANSFORM_FEEDBACK_ATTRIBS_NV
#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV                                0x8C7E
#endif //GL_TRANSFORM_FEEDBACK_ATTRIBS_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_MODE
#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE                               0x8C7F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_MODE
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT
#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT                           0x8C7F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV                            0x8C7F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV                0x8C80
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS                   0x8C80
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT               0x8C80
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT
#ifndef GL_ACTIVE_VARYINGS_NV
#define GL_ACTIVE_VARYINGS_NV                                           0x8C81
#endif //GL_ACTIVE_VARYINGS_NV
#ifndef GL_ACTIVE_VARYING_MAX_LENGTH_NV
#define GL_ACTIVE_VARYING_MAX_LENGTH_NV                                 0x8C82
#endif //GL_ACTIVE_VARYING_MAX_LENGTH_NV
#ifndef GL_TRANSFORM_FEEDBACK_VARYINGS_EXT
#define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT                              0x8C83
#endif //GL_TRANSFORM_FEEDBACK_VARYINGS_EXT
#ifndef GL_TRANSFORM_FEEDBACK_VARYINGS
#define GL_TRANSFORM_FEEDBACK_VARYINGS                                  0x8C83
#endif //GL_TRANSFORM_FEEDBACK_VARYINGS
#ifndef GL_TRANSFORM_FEEDBACK_VARYINGS_NV
#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV                               0x8C83
#endif //GL_TRANSFORM_FEEDBACK_VARYINGS_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT
#define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT                          0x8C84
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_START_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV                           0x8C84
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_START_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_START
#define GL_TRANSFORM_FEEDBACK_BUFFER_START                              0x8C84
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_START
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_SIZE
#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE                               0x8C85
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_SIZE
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT
#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT                           0x8C85
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV                            0x8C85
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV
#ifndef GL_TRANSFORM_FEEDBACK_RECORD_NV
#define GL_TRANSFORM_FEEDBACK_RECORD_NV                                 0x8C86
#endif //GL_TRANSFORM_FEEDBACK_RECORD_NV
#ifndef GL_PRIMITIVES_GENERATED
#define GL_PRIMITIVES_GENERATED                                         0x8C87
#endif //GL_PRIMITIVES_GENERATED
#ifndef GL_PRIMITIVES_GENERATED_NV
#define GL_PRIMITIVES_GENERATED_NV                                      0x8C87
#endif //GL_PRIMITIVES_GENERATED_NV
#ifndef GL_PRIMITIVES_GENERATED_EXT
#define GL_PRIMITIVES_GENERATED_EXT                                     0x8C87
#endif //GL_PRIMITIVES_GENERATED_EXT
#ifndef GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT
#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT                    0x8C88
#endif //GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT
#ifndef GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN                        0x8C88
#endif //GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
#ifndef GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV
#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV                     0x8C88
#endif //GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV
#ifndef GL_RASTERIZER_DISCARD_EXT
#define GL_RASTERIZER_DISCARD_EXT                                       0x8C89
#endif //GL_RASTERIZER_DISCARD_EXT
#ifndef GL_RASTERIZER_DISCARD_NV
#define GL_RASTERIZER_DISCARD_NV                                        0x8C89
#endif //GL_RASTERIZER_DISCARD_NV
#ifndef GL_RASTERIZER_DISCARD
#define GL_RASTERIZER_DISCARD                                           0x8C89
#endif //GL_RASTERIZER_DISCARD
#ifndef GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT
#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT            0x8C8A
#endif //GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT
#ifndef GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV
#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV             0x8C8A
#endif //GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV
#ifndef GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS                0x8C8A
#endif //GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT                  0x8C8B
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS                      0x8C8B
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS
#ifndef GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV                   0x8C8B
#endif //GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV
#ifndef GL_INTERLEAVED_ATTRIBS_NV
#define GL_INTERLEAVED_ATTRIBS_NV                                       0x8C8C
#endif //GL_INTERLEAVED_ATTRIBS_NV
#ifndef GL_INTERLEAVED_ATTRIBS
#define GL_INTERLEAVED_ATTRIBS                                          0x8C8C
#endif //GL_INTERLEAVED_ATTRIBS
#ifndef GL_INTERLEAVED_ATTRIBS_EXT
#define GL_INTERLEAVED_ATTRIBS_EXT                                      0x8C8C
#endif //GL_INTERLEAVED_ATTRIBS_EXT
#ifndef GL_SEPARATE_ATTRIBS
#define GL_SEPARATE_ATTRIBS                                             0x8C8D
#endif //GL_SEPARATE_ATTRIBS
#ifndef GL_SEPARATE_ATTRIBS_EXT
#define GL_SEPARATE_ATTRIBS_EXT                                         0x8C8D
#endif //GL_SEPARATE_ATTRIBS_EXT
#ifndef GL_SEPARATE_ATTRIBS_NV
#define GL_SEPARATE_ATTRIBS_NV                                          0x8C8D
#endif //GL_SEPARATE_ATTRIBS_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_EXT
#define GL_TRANSFORM_FEEDBACK_BUFFER_EXT                                0x8C8E
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_EXT
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_NV                                 0x8C8E
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER
#define GL_TRANSFORM_FEEDBACK_BUFFER                                    0x8C8E
#endif //GL_TRANSFORM_FEEDBACK_BUFFER
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV                         0x8C8F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_BINDING
#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING                            0x8C8F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_BINDING
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT
#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT                        0x8C8F
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT
#ifndef GL_LAYER_NV
#define GL_LAYER_NV                                                     0x8DAA
#endif //GL_LAYER_NV

#endif //GL_NV_transform_feedback


typedef void (*PFNBEGINTRANSFORMFEEDBACKNVPROC_HPP)(GLenum primitiveMode);

static inline void BeginTransformFeedbackNV(GLenum primitiveMode)
{
	static PFNBEGINTRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNBEGINTRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glBeginTransformFeedbackNV","GL_NV_transform_feedback"));
	 fn(primitiveMode);
}

typedef void (*PFNENDTRANSFORMFEEDBACKNVPROC_HPP)();

static inline void EndTransformFeedbackNV()
{
	static PFNENDTRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNENDTRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glEndTransformFeedbackNV","GL_NV_transform_feedback"));
	 fn();
}

typedef void (*PFNTRANSFORMFEEDBACKATTRIBSNVPROC_HPP)(GLsizei count,const GLint *attribs,GLenum bufferMode);

static inline void TransformFeedbackAttribsNV(GLsizei count,const GLint *attribs,GLenum bufferMode)
{
	static PFNTRANSFORMFEEDBACKATTRIBSNVPROC_HPP fn=reinterpret_cast<PFNTRANSFORMFEEDBACKATTRIBSNVPROC_HPP>(_impl::_get_proc_address("glTransformFeedbackAttribsNV","GL_NV_transform_feedback"));
	 fn(count,attribs,bufferMode);
}

typedef void (*PFNBINDBUFFERRANGENVPROC_HPP)(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size);

static inline void BindBufferRangeNV(GLenum target,GLuint index,GLuint buffer,GLintptr offset,GLsizeiptr size)
{
	static PFNBINDBUFFERRANGENVPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERRANGENVPROC_HPP>(_impl::_get_proc_address("glBindBufferRangeNV","GL_NV_transform_feedback"));
	 fn(target,index,buffer,offset,size);
}

typedef void (*PFNBINDBUFFEROFFSETNVPROC_HPP)(GLenum target,GLuint index,GLuint buffer,GLintptr offset);

static inline void BindBufferOffsetNV(GLenum target,GLuint index,GLuint buffer,GLintptr offset)
{
	static PFNBINDBUFFEROFFSETNVPROC_HPP fn=reinterpret_cast<PFNBINDBUFFEROFFSETNVPROC_HPP>(_impl::_get_proc_address("glBindBufferOffsetNV","GL_NV_transform_feedback"));
	 fn(target,index,buffer,offset);
}

typedef void (*PFNBINDBUFFERBASENVPROC_HPP)(GLenum target,GLuint index,GLuint buffer);

static inline void BindBufferBaseNV(GLenum target,GLuint index,GLuint buffer)
{
	static PFNBINDBUFFERBASENVPROC_HPP fn=reinterpret_cast<PFNBINDBUFFERBASENVPROC_HPP>(_impl::_get_proc_address("glBindBufferBaseNV","GL_NV_transform_feedback"));
	 fn(target,index,buffer);
}

typedef void (*PFNTRANSFORMFEEDBACKVARYINGSNVPROC_HPP)(GLuint program,GLsizei count,const GLint *locations,GLenum bufferMode);

static inline void TransformFeedbackVaryingsNV(GLuint program,GLsizei count,const GLint *locations,GLenum bufferMode)
{
	static PFNTRANSFORMFEEDBACKVARYINGSNVPROC_HPP fn=reinterpret_cast<PFNTRANSFORMFEEDBACKVARYINGSNVPROC_HPP>(_impl::_get_proc_address("glTransformFeedbackVaryingsNV","GL_NV_transform_feedback"));
	 fn(program,count,locations,bufferMode);
}

typedef void (*PFNACTIVEVARYINGNVPROC_HPP)(GLuint program,const GLchar *name);

static inline void ActiveVaryingNV(GLuint program,const GLchar *name)
{
	static PFNACTIVEVARYINGNVPROC_HPP fn=reinterpret_cast<PFNACTIVEVARYINGNVPROC_HPP>(_impl::_get_proc_address("glActiveVaryingNV","GL_NV_transform_feedback"));
	 fn(program,name);
}

typedef GLint (*PFNGETVARYINGLOCATIONNVPROC_HPP)(GLuint program,const GLchar *name);

static inline GLint GetVaryingLocationNV(GLuint program,const GLchar *name)
{
	static PFNGETVARYINGLOCATIONNVPROC_HPP fn=reinterpret_cast<PFNGETVARYINGLOCATIONNVPROC_HPP>(_impl::_get_proc_address("glGetVaryingLocationNV","GL_NV_transform_feedback"));
	return fn(program,name);
}

typedef void (*PFNGETACTIVEVARYINGNVPROC_HPP)(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name);

static inline void GetActiveVaryingNV(GLuint program,GLuint index,GLsizei bufSize,GLsizei *length,GLsizei *size,GLenum *type,GLchar *name)
{
	static PFNGETACTIVEVARYINGNVPROC_HPP fn=reinterpret_cast<PFNGETACTIVEVARYINGNVPROC_HPP>(_impl::_get_proc_address("glGetActiveVaryingNV","GL_NV_transform_feedback"));
	 fn(program,index,bufSize,length,size,type,name);
}

typedef void (*PFNGETTRANSFORMFEEDBACKVARYINGNVPROC_HPP)(GLuint program,GLuint index,GLint *location);

static inline void GetTransformFeedbackVaryingNV(GLuint program,GLuint index,GLint *location)
{
	static PFNGETTRANSFORMFEEDBACKVARYINGNVPROC_HPP fn=reinterpret_cast<PFNGETTRANSFORMFEEDBACKVARYINGNVPROC_HPP>(_impl::_get_proc_address("glGetTransformFeedbackVaryingNV","GL_NV_transform_feedback"));
	 fn(program,index,location);
}

typedef void (*PFNTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC_HPP)(GLsizei count,const GLint *attribs,GLsizei nbuffers,const GLint *bufstreams,GLenum bufferMode);

static inline void TransformFeedbackStreamAttribsNV(GLsizei count,const GLint *attribs,GLsizei nbuffers,const GLint *bufstreams,GLenum bufferMode)
{
	static PFNTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC_HPP fn=reinterpret_cast<PFNTRANSFORMFEEDBACKSTREAMATTRIBSNVPROC_HPP>(_impl::_get_proc_address("glTransformFeedbackStreamAttribsNV","GL_NV_transform_feedback"));
	 fn(count,attribs,nbuffers,bufstreams,bufferMode);
}
#ifndef GL_NV_transform_feedback2

#define GL_NV_transform_feedback2
#ifndef GL_TRANSFORM_FEEDBACK_NV
#define GL_TRANSFORM_FEEDBACK_NV                                        0x8E22
#endif //GL_TRANSFORM_FEEDBACK_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV                          0x8E23
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV
#ifndef GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV
#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV                          0x8E24
#endif //GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV
#ifndef GL_TRANSFORM_FEEDBACK_BINDING_NV
#define GL_TRANSFORM_FEEDBACK_BINDING_NV                                0x8E25
#endif //GL_TRANSFORM_FEEDBACK_BINDING_NV

#endif //GL_NV_transform_feedback2


typedef void (*PFNBINDTRANSFORMFEEDBACKNVPROC_HPP)(GLenum target,GLuint id);

static inline void BindTransformFeedbackNV(GLenum target,GLuint id)
{
	static PFNBINDTRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNBINDTRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glBindTransformFeedbackNV","GL_NV_transform_feedback2"));
	 fn(target,id);
}

typedef void (*PFNDELETETRANSFORMFEEDBACKSNVPROC_HPP)(GLsizei n,const GLuint *ids);

static inline void DeleteTransformFeedbacksNV(GLsizei n,const GLuint *ids)
{
	static PFNDELETETRANSFORMFEEDBACKSNVPROC_HPP fn=reinterpret_cast<PFNDELETETRANSFORMFEEDBACKSNVPROC_HPP>(_impl::_get_proc_address("glDeleteTransformFeedbacksNV","GL_NV_transform_feedback2"));
	 fn(n,ids);
}

typedef void (*PFNGENTRANSFORMFEEDBACKSNVPROC_HPP)(GLsizei n,GLuint *ids);

static inline void GenTransformFeedbacksNV(GLsizei n,GLuint *ids)
{
	static PFNGENTRANSFORMFEEDBACKSNVPROC_HPP fn=reinterpret_cast<PFNGENTRANSFORMFEEDBACKSNVPROC_HPP>(_impl::_get_proc_address("glGenTransformFeedbacksNV","GL_NV_transform_feedback2"));
	 fn(n,ids);
}

typedef GLboolean (*PFNISTRANSFORMFEEDBACKNVPROC_HPP)(GLuint id);

static inline GLboolean IsTransformFeedbackNV(GLuint id)
{
	static PFNISTRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNISTRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glIsTransformFeedbackNV","GL_NV_transform_feedback2"));
	return fn(id);
}

typedef void (*PFNPAUSETRANSFORMFEEDBACKNVPROC_HPP)();

static inline void PauseTransformFeedbackNV()
{
	static PFNPAUSETRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNPAUSETRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glPauseTransformFeedbackNV","GL_NV_transform_feedback2"));
	 fn();
}

typedef void (*PFNRESUMETRANSFORMFEEDBACKNVPROC_HPP)();

static inline void ResumeTransformFeedbackNV()
{
	static PFNRESUMETRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNRESUMETRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glResumeTransformFeedbackNV","GL_NV_transform_feedback2"));
	 fn();
}

typedef void (*PFNDRAWTRANSFORMFEEDBACKNVPROC_HPP)(GLenum mode,GLuint id);

static inline void DrawTransformFeedbackNV(GLenum mode,GLuint id)
{
	static PFNDRAWTRANSFORMFEEDBACKNVPROC_HPP fn=reinterpret_cast<PFNDRAWTRANSFORMFEEDBACKNVPROC_HPP>(_impl::_get_proc_address("glDrawTransformFeedbackNV","GL_NV_transform_feedback2"));
	 fn(mode,id);
}
#ifndef GL_NV_vdpau_interop

#define GL_NV_vdpau_interop
#ifndef GL_SURFACE_STATE_NV
#define GL_SURFACE_STATE_NV                                             0x86EB
#endif //GL_SURFACE_STATE_NV
#ifndef GL_SURFACE_REGISTERED_NV
#define GL_SURFACE_REGISTERED_NV                                        0x86FD
#endif //GL_SURFACE_REGISTERED_NV
#ifndef GL_SURFACE_MAPPED_NV
#define GL_SURFACE_MAPPED_NV                                            0x8700
#endif //GL_SURFACE_MAPPED_NV
#ifndef GL_WRITE_DISCARD_NV
#define GL_WRITE_DISCARD_NV                                             0x88BE
#endif //GL_WRITE_DISCARD_NV

#endif //GL_NV_vdpau_interop


typedef void (*PFNVDPAUINITNVPROC_HPP)(const GLvoid *vdpDevice,const GLvoid *getProcAddress);

static inline void VDPAUInitNV(const GLvoid *vdpDevice,const GLvoid *getProcAddress)
{
	static PFNVDPAUINITNVPROC_HPP fn=reinterpret_cast<PFNVDPAUINITNVPROC_HPP>(_impl::_get_proc_address("glVDPAUInitNV","GL_NV_vdpau_interop"));
	 fn(vdpDevice,getProcAddress);
}

typedef void (*PFNVDPAUFININVPROC_HPP)();

static inline void VDPAUFiniNV()
{
	static PFNVDPAUFININVPROC_HPP fn=reinterpret_cast<PFNVDPAUFININVPROC_HPP>(_impl::_get_proc_address("glVDPAUFiniNV","GL_NV_vdpau_interop"));
	 fn();
}

typedef GLvdpauSurfaceNV (*PFNVDPAUREGISTERVIDEOSURFACENVPROC_HPP)(const GLvoid *vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint *textureNames);

static inline GLvdpauSurfaceNV VDPAURegisterVideoSurfaceNV(const GLvoid *vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint *textureNames)
{
	static PFNVDPAUREGISTERVIDEOSURFACENVPROC_HPP fn=reinterpret_cast<PFNVDPAUREGISTERVIDEOSURFACENVPROC_HPP>(_impl::_get_proc_address("glVDPAURegisterVideoSurfaceNV","GL_NV_vdpau_interop"));
	return fn(vdpSurface,target,numTextureNames,textureNames);
}

typedef GLvdpauSurfaceNV (*PFNVDPAUREGISTEROUTPUTSURFACENVPROC_HPP)(GLvoid* vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint *textureNames);

static inline GLvdpauSurfaceNV VDPAURegisterOutputSurfaceNV(GLvoid* vdpSurface,GLenum target,GLsizei numTextureNames,const GLuint *textureNames)
{
	static PFNVDPAUREGISTEROUTPUTSURFACENVPROC_HPP fn=reinterpret_cast<PFNVDPAUREGISTEROUTPUTSURFACENVPROC_HPP>(_impl::_get_proc_address("glVDPAURegisterOutputSurfaceNV","GL_NV_vdpau_interop"));
	return fn(vdpSurface,target,numTextureNames,textureNames);
}

typedef void (*PFNVDPAUISSURFACENVPROC_HPP)(GLvdpauSurfaceNV surface);

static inline void VDPAUIsSurfaceNV(GLvdpauSurfaceNV surface)
{
	static PFNVDPAUISSURFACENVPROC_HPP fn=reinterpret_cast<PFNVDPAUISSURFACENVPROC_HPP>(_impl::_get_proc_address("glVDPAUIsSurfaceNV","GL_NV_vdpau_interop"));
	 fn(surface);
}

typedef void (*PFNVDPAUUNREGISTERSURFACENVPROC_HPP)(GLvdpauSurfaceNV surface);

static inline void VDPAUUnregisterSurfaceNV(GLvdpauSurfaceNV surface)
{
	static PFNVDPAUUNREGISTERSURFACENVPROC_HPP fn=reinterpret_cast<PFNVDPAUUNREGISTERSURFACENVPROC_HPP>(_impl::_get_proc_address("glVDPAUUnregisterSurfaceNV","GL_NV_vdpau_interop"));
	 fn(surface);
}

typedef void (*PFNVDPAUGETSURFACEIVNVPROC_HPP)(GLvdpauSurfaceNV surface,GLenum pname,GLsizei bufSize,GLsizei *length,GLint *values);

static inline void VDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface,GLenum pname,GLsizei bufSize,GLsizei *length,GLint *values)
{
	static PFNVDPAUGETSURFACEIVNVPROC_HPP fn=reinterpret_cast<PFNVDPAUGETSURFACEIVNVPROC_HPP>(_impl::_get_proc_address("glVDPAUGetSurfaceivNV","GL_NV_vdpau_interop"));
	 fn(surface,pname,bufSize,length,values);
}

typedef void (*PFNVDPAUSURFACEACCESSNVPROC_HPP)(GLvdpauSurfaceNV surface,GLenum access);

static inline void VDPAUSurfaceAccessNV(GLvdpauSurfaceNV surface,GLenum access)
{
	static PFNVDPAUSURFACEACCESSNVPROC_HPP fn=reinterpret_cast<PFNVDPAUSURFACEACCESSNVPROC_HPP>(_impl::_get_proc_address("glVDPAUSurfaceAccessNV","GL_NV_vdpau_interop"));
	 fn(surface,access);
}

typedef void (*PFNVDPAUMAPSURFACESNVPROC_HPP)(GLsizei numSurfaces,const GLvdpauSurfaceNV *surfaces);

static inline void VDPAUMapSurfacesNV(GLsizei numSurfaces,const GLvdpauSurfaceNV *surfaces)
{
	static PFNVDPAUMAPSURFACESNVPROC_HPP fn=reinterpret_cast<PFNVDPAUMAPSURFACESNVPROC_HPP>(_impl::_get_proc_address("glVDPAUMapSurfacesNV","GL_NV_vdpau_interop"));
	 fn(numSurfaces,surfaces);
}

typedef void (*PFNVDPAUUNMAPSURFACESNVPROC_HPP)(GLsizei numSurface,const GLvdpauSurfaceNV *surfaces);

static inline void VDPAUUnmapSurfacesNV(GLsizei numSurface,const GLvdpauSurfaceNV *surfaces)
{
	static PFNVDPAUUNMAPSURFACESNVPROC_HPP fn=reinterpret_cast<PFNVDPAUUNMAPSURFACESNVPROC_HPP>(_impl::_get_proc_address("glVDPAUUnmapSurfacesNV","GL_NV_vdpau_interop"));
	 fn(numSurface,surfaces);
}
#ifndef GL_NV_vertex_array_range

#define GL_NV_vertex_array_range
#ifndef GL_VERTEX_ARRAY_RANGE_NV
#define GL_VERTEX_ARRAY_RANGE_NV                                        0x851D
#endif //GL_VERTEX_ARRAY_RANGE_NV
#ifndef GL_VERTEX_ARRAY_RANGE_LENGTH_NV
#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV                                 0x851E
#endif //GL_VERTEX_ARRAY_RANGE_LENGTH_NV
#ifndef GL_VERTEX_ARRAY_RANGE_VALID_NV
#define GL_VERTEX_ARRAY_RANGE_VALID_NV                                  0x851F
#endif //GL_VERTEX_ARRAY_RANGE_VALID_NV
#ifndef GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV
#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV                            0x8520
#endif //GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV
#ifndef GL_VERTEX_ARRAY_RANGE_POINTER_NV
#define GL_VERTEX_ARRAY_RANGE_POINTER_NV                                0x8521
#endif //GL_VERTEX_ARRAY_RANGE_POINTER_NV

#endif //GL_NV_vertex_array_range


typedef void (*PFNFLUSHVERTEXARRAYRANGENVPROC_HPP)();

static inline void FlushVertexArrayRangeNV()
{
	static PFNFLUSHVERTEXARRAYRANGENVPROC_HPP fn=reinterpret_cast<PFNFLUSHVERTEXARRAYRANGENVPROC_HPP>(_impl::_get_proc_address("glFlushVertexArrayRangeNV","GL_NV_vertex_array_range"));
	 fn();
}

typedef void (*PFNVERTEXARRAYRANGENVPROC_HPP)(GLsizei length,const GLvoid *pointer);

static inline void VertexArrayRangeNV(GLsizei length,const GLvoid *pointer)
{
	static PFNVERTEXARRAYRANGENVPROC_HPP fn=reinterpret_cast<PFNVERTEXARRAYRANGENVPROC_HPP>(_impl::_get_proc_address("glVertexArrayRangeNV","GL_NV_vertex_array_range"));
	 fn(length,pointer);
}
#ifndef GL_NV_vertex_attrib_integer_64bit

#define GL_NV_vertex_attrib_integer_64bit

#endif //GL_NV_vertex_attrib_integer_64bit


typedef void (*PFNVERTEXATTRIBL1I64NVPROC_HPP)(GLuint index,GLint64EXT x);

static inline void VertexAttribL1i64NV(GLuint index,GLint64EXT x)
{
	static PFNVERTEXATTRIBL1I64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1I64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1i64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBL2I64NVPROC_HPP)(GLuint index,GLint64EXT x,GLint64EXT y);

static inline void VertexAttribL2i64NV(GLuint index,GLint64EXT x,GLint64EXT y)
{
	static PFNVERTEXATTRIBL2I64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2I64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2i64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBL3I64NVPROC_HPP)(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z);

static inline void VertexAttribL3i64NV(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z)
{
	static PFNVERTEXATTRIBL3I64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3I64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3i64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBL4I64NVPROC_HPP)(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w);

static inline void VertexAttribL4i64NV(GLuint index,GLint64EXT x,GLint64EXT y,GLint64EXT z,GLint64EXT w)
{
	static PFNVERTEXATTRIBL4I64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4I64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4i64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBL1I64VNVPROC_HPP)(GLuint index,const GLint64EXT *v);

static inline void VertexAttribL1i64vNV(GLuint index,const GLint64EXT *v)
{
	static PFNVERTEXATTRIBL1I64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1I64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1i64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL2I64VNVPROC_HPP)(GLuint index,const GLint64EXT *v);

static inline void VertexAttribL2i64vNV(GLuint index,const GLint64EXT *v)
{
	static PFNVERTEXATTRIBL2I64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2I64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2i64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL3I64VNVPROC_HPP)(GLuint index,const GLint64EXT *v);

static inline void VertexAttribL3i64vNV(GLuint index,const GLint64EXT *v)
{
	static PFNVERTEXATTRIBL3I64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3I64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3i64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL4I64VNVPROC_HPP)(GLuint index,const GLint64EXT *v);

static inline void VertexAttribL4i64vNV(GLuint index,const GLint64EXT *v)
{
	static PFNVERTEXATTRIBL4I64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4I64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4i64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL1UI64NVPROC_HPP)(GLuint index,GLuint64EXT x);

static inline void VertexAttribL1ui64NV(GLuint index,GLuint64EXT x)
{
	static PFNVERTEXATTRIBL1UI64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1UI64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1ui64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBL2UI64NVPROC_HPP)(GLuint index,GLuint64EXT x,GLuint64EXT y);

static inline void VertexAttribL2ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y)
{
	static PFNVERTEXATTRIBL2UI64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2UI64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2ui64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBL3UI64NVPROC_HPP)(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z);

static inline void VertexAttribL3ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z)
{
	static PFNVERTEXATTRIBL3UI64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3UI64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3ui64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBL4UI64NVPROC_HPP)(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w);

static inline void VertexAttribL4ui64NV(GLuint index,GLuint64EXT x,GLuint64EXT y,GLuint64EXT z,GLuint64EXT w)
{
	static PFNVERTEXATTRIBL4UI64NVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4UI64NVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4ui64NV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBL1UI64VNVPROC_HPP)(GLuint index,const GLuint64EXT *v);

static inline void VertexAttribL1ui64vNV(GLuint index,const GLuint64EXT *v)
{
	static PFNVERTEXATTRIBL1UI64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL1UI64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL1ui64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL2UI64VNVPROC_HPP)(GLuint index,const GLuint64EXT *v);

static inline void VertexAttribL2ui64vNV(GLuint index,const GLuint64EXT *v)
{
	static PFNVERTEXATTRIBL2UI64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL2UI64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL2ui64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL3UI64VNVPROC_HPP)(GLuint index,const GLuint64EXT *v);

static inline void VertexAttribL3ui64vNV(GLuint index,const GLuint64EXT *v)
{
	static PFNVERTEXATTRIBL3UI64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL3UI64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL3ui64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBL4UI64VNVPROC_HPP)(GLuint index,const GLuint64EXT *v);

static inline void VertexAttribL4ui64vNV(GLuint index,const GLuint64EXT *v)
{
	static PFNVERTEXATTRIBL4UI64VNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBL4UI64VNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribL4ui64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,v);
}

typedef void (*PFNGETVERTEXATTRIBLI64VNVPROC_HPP)(GLuint index,GLenum pname,GLint64EXT *params);

static inline void GetVertexAttribLi64vNV(GLuint index,GLenum pname,GLint64EXT *params)
{
	static PFNGETVERTEXATTRIBLI64VNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBLI64VNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribLi64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBLUI64VNVPROC_HPP)(GLuint index,GLenum pname,GLuint64EXT *params);

static inline void GetVertexAttribLui64vNV(GLuint index,GLenum pname,GLuint64EXT *params)
{
	static PFNGETVERTEXATTRIBLUI64VNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBLUI64VNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribLui64vNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,pname,params);
}

typedef void (*PFNVERTEXATTRIBLFORMATNVPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride);

static inline void VertexAttribLFormatNV(GLuint index,GLint size,GLenum type,GLsizei stride)
{
	static PFNVERTEXATTRIBLFORMATNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBLFORMATNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribLFormatNV","GL_NV_vertex_attrib_integer_64bit"));
	 fn(index,size,type,stride);
}
#ifndef GL_NV_vertex_buffer_unified_memory

#define GL_NV_vertex_buffer_unified_memory
#ifndef GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV
#define GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV                               0x8F1E
#endif //GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV
#ifndef GL_ELEMENT_ARRAY_UNIFIED_NV
#define GL_ELEMENT_ARRAY_UNIFIED_NV                                     0x8F1F
#endif //GL_ELEMENT_ARRAY_UNIFIED_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV
#define GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV                               0x8F20
#endif //GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV
#ifndef GL_VERTEX_ARRAY_ADDRESS_NV
#define GL_VERTEX_ARRAY_ADDRESS_NV                                      0x8F21
#endif //GL_VERTEX_ARRAY_ADDRESS_NV
#ifndef GL_NORMAL_ARRAY_ADDRESS_NV
#define GL_NORMAL_ARRAY_ADDRESS_NV                                      0x8F22
#endif //GL_NORMAL_ARRAY_ADDRESS_NV
#ifndef GL_COLOR_ARRAY_ADDRESS_NV
#define GL_COLOR_ARRAY_ADDRESS_NV                                       0x8F23
#endif //GL_COLOR_ARRAY_ADDRESS_NV
#ifndef GL_INDEX_ARRAY_ADDRESS_NV
#define GL_INDEX_ARRAY_ADDRESS_NV                                       0x8F24
#endif //GL_INDEX_ARRAY_ADDRESS_NV
#ifndef GL_TEXTURE_COORD_ARRAY_ADDRESS_NV
#define GL_TEXTURE_COORD_ARRAY_ADDRESS_NV                               0x8F25
#endif //GL_TEXTURE_COORD_ARRAY_ADDRESS_NV
#ifndef GL_EDGE_FLAG_ARRAY_ADDRESS_NV
#define GL_EDGE_FLAG_ARRAY_ADDRESS_NV                                   0x8F26
#endif //GL_EDGE_FLAG_ARRAY_ADDRESS_NV
#ifndef GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV
#define GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV                             0x8F27
#endif //GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV
#ifndef GL_FOG_COORD_ARRAY_ADDRESS_NV
#define GL_FOG_COORD_ARRAY_ADDRESS_NV                                   0x8F28
#endif //GL_FOG_COORD_ARRAY_ADDRESS_NV
#ifndef GL_ELEMENT_ARRAY_ADDRESS_NV
#define GL_ELEMENT_ARRAY_ADDRESS_NV                                     0x8F29
#endif //GL_ELEMENT_ARRAY_ADDRESS_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV
#define GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV                                0x8F2A
#endif //GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV
#ifndef GL_VERTEX_ARRAY_LENGTH_NV
#define GL_VERTEX_ARRAY_LENGTH_NV                                       0x8F2B
#endif //GL_VERTEX_ARRAY_LENGTH_NV
#ifndef GL_NORMAL_ARRAY_LENGTH_NV
#define GL_NORMAL_ARRAY_LENGTH_NV                                       0x8F2C
#endif //GL_NORMAL_ARRAY_LENGTH_NV
#ifndef GL_COLOR_ARRAY_LENGTH_NV
#define GL_COLOR_ARRAY_LENGTH_NV                                        0x8F2D
#endif //GL_COLOR_ARRAY_LENGTH_NV
#ifndef GL_INDEX_ARRAY_LENGTH_NV
#define GL_INDEX_ARRAY_LENGTH_NV                                        0x8F2E
#endif //GL_INDEX_ARRAY_LENGTH_NV
#ifndef GL_TEXTURE_COORD_ARRAY_LENGTH_NV
#define GL_TEXTURE_COORD_ARRAY_LENGTH_NV                                0x8F2F
#endif //GL_TEXTURE_COORD_ARRAY_LENGTH_NV
#ifndef GL_EDGE_FLAG_ARRAY_LENGTH_NV
#define GL_EDGE_FLAG_ARRAY_LENGTH_NV                                    0x8F30
#endif //GL_EDGE_FLAG_ARRAY_LENGTH_NV
#ifndef GL_SECONDARY_COLOR_ARRAY_LENGTH_NV
#define GL_SECONDARY_COLOR_ARRAY_LENGTH_NV                              0x8F31
#endif //GL_SECONDARY_COLOR_ARRAY_LENGTH_NV
#ifndef GL_FOG_COORD_ARRAY_LENGTH_NV
#define GL_FOG_COORD_ARRAY_LENGTH_NV                                    0x8F32
#endif //GL_FOG_COORD_ARRAY_LENGTH_NV
#ifndef GL_ELEMENT_ARRAY_LENGTH_NV
#define GL_ELEMENT_ARRAY_LENGTH_NV                                      0x8F33
#endif //GL_ELEMENT_ARRAY_LENGTH_NV
#ifndef GL_DRAW_INDIRECT_UNIFIED_NV
#define GL_DRAW_INDIRECT_UNIFIED_NV                                     0x8F40
#endif //GL_DRAW_INDIRECT_UNIFIED_NV
#ifndef GL_DRAW_INDIRECT_ADDRESS_NV
#define GL_DRAW_INDIRECT_ADDRESS_NV                                     0x8F41
#endif //GL_DRAW_INDIRECT_ADDRESS_NV
#ifndef GL_DRAW_INDIRECT_LENGTH_NV
#define GL_DRAW_INDIRECT_LENGTH_NV                                      0x8F42
#endif //GL_DRAW_INDIRECT_LENGTH_NV

#endif //GL_NV_vertex_buffer_unified_memory


typedef void (*PFNBUFFERADDRESSRANGENVPROC_HPP)(GLenum pname,GLuint index,GLuint64EXT address,GLsizeiptr length);

static inline void BufferAddressRangeNV(GLenum pname,GLuint index,GLuint64EXT address,GLsizeiptr length)
{
	static PFNBUFFERADDRESSRANGENVPROC_HPP fn=reinterpret_cast<PFNBUFFERADDRESSRANGENVPROC_HPP>(_impl::_get_proc_address("glBufferAddressRangeNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(pname,index,address,length);
}

typedef void (*PFNVERTEXFORMATNVPROC_HPP)(GLint size,GLenum type,GLsizei stride);

static inline void VertexFormatNV(GLint size,GLenum type,GLsizei stride)
{
	static PFNVERTEXFORMATNVPROC_HPP fn=reinterpret_cast<PFNVERTEXFORMATNVPROC_HPP>(_impl::_get_proc_address("glVertexFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(size,type,stride);
}

typedef void (*PFNNORMALFORMATNVPROC_HPP)(GLenum type,GLsizei stride);

static inline void NormalFormatNV(GLenum type,GLsizei stride)
{
	static PFNNORMALFORMATNVPROC_HPP fn=reinterpret_cast<PFNNORMALFORMATNVPROC_HPP>(_impl::_get_proc_address("glNormalFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(type,stride);
}

typedef void (*PFNCOLORFORMATNVPROC_HPP)(GLint size,GLenum type,GLsizei stride);

static inline void ColorFormatNV(GLint size,GLenum type,GLsizei stride)
{
	static PFNCOLORFORMATNVPROC_HPP fn=reinterpret_cast<PFNCOLORFORMATNVPROC_HPP>(_impl::_get_proc_address("glColorFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(size,type,stride);
}

typedef void (*PFNINDEXFORMATNVPROC_HPP)(GLenum type,GLsizei stride);

static inline void IndexFormatNV(GLenum type,GLsizei stride)
{
	static PFNINDEXFORMATNVPROC_HPP fn=reinterpret_cast<PFNINDEXFORMATNVPROC_HPP>(_impl::_get_proc_address("glIndexFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(type,stride);
}

typedef void (*PFNTEXCOORDFORMATNVPROC_HPP)(GLint size,GLenum type,GLsizei stride);

static inline void TexCoordFormatNV(GLint size,GLenum type,GLsizei stride)
{
	static PFNTEXCOORDFORMATNVPROC_HPP fn=reinterpret_cast<PFNTEXCOORDFORMATNVPROC_HPP>(_impl::_get_proc_address("glTexCoordFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(size,type,stride);
}

typedef void (*PFNEDGEFLAGFORMATNVPROC_HPP)(GLsizei stride);

static inline void EdgeFlagFormatNV(GLsizei stride)
{
	static PFNEDGEFLAGFORMATNVPROC_HPP fn=reinterpret_cast<PFNEDGEFLAGFORMATNVPROC_HPP>(_impl::_get_proc_address("glEdgeFlagFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(stride);
}

typedef void (*PFNSECONDARYCOLORFORMATNVPROC_HPP)(GLint size,GLenum type,GLsizei stride);

static inline void SecondaryColorFormatNV(GLint size,GLenum type,GLsizei stride)
{
	static PFNSECONDARYCOLORFORMATNVPROC_HPP fn=reinterpret_cast<PFNSECONDARYCOLORFORMATNVPROC_HPP>(_impl::_get_proc_address("glSecondaryColorFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(size,type,stride);
}

typedef void (*PFNFOGCOORDFORMATNVPROC_HPP)(GLenum type,GLsizei stride);

static inline void FogCoordFormatNV(GLenum type,GLsizei stride)
{
	static PFNFOGCOORDFORMATNVPROC_HPP fn=reinterpret_cast<PFNFOGCOORDFORMATNVPROC_HPP>(_impl::_get_proc_address("glFogCoordFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(type,stride);
}

typedef void (*PFNVERTEXATTRIBFORMATNVPROC_HPP)(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride);

static inline void VertexAttribFormatNV(GLuint index,GLint size,GLenum type,GLboolean normalized,GLsizei stride)
{
	static PFNVERTEXATTRIBFORMATNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBFORMATNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(index,size,type,normalized,stride);
}

typedef void (*PFNVERTEXATTRIBIFORMATNVPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride);

static inline void VertexAttribIFormatNV(GLuint index,GLint size,GLenum type,GLsizei stride)
{
	static PFNVERTEXATTRIBIFORMATNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBIFORMATNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribIFormatNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(index,size,type,stride);
}

typedef void (*PFNGETINTEGERUI64I_VNVPROC_HPP)(GLenum value,GLuint index,GLuint64EXT *result);

static inline void GetIntegerui64i_vNV(GLenum value,GLuint index,GLuint64EXT *result)
{
	static PFNGETINTEGERUI64I_VNVPROC_HPP fn=reinterpret_cast<PFNGETINTEGERUI64I_VNVPROC_HPP>(_impl::_get_proc_address("glGetIntegerui64i_vNV","GL_NV_vertex_buffer_unified_memory"));
	 fn(value,index,result);
}
#ifndef GL_NV_vertex_program

#define GL_NV_vertex_program
#ifndef GL_VERTEX_PROGRAM_NV
#define GL_VERTEX_PROGRAM_NV                                            0x8620
#endif //GL_VERTEX_PROGRAM_NV
#ifndef GL_VERTEX_STATE_PROGRAM_NV
#define GL_VERTEX_STATE_PROGRAM_NV                                      0x8621
#endif //GL_VERTEX_STATE_PROGRAM_NV
#ifndef GL_ATTRIB_ARRAY_SIZE_NV
#define GL_ATTRIB_ARRAY_SIZE_NV                                         0x8623
#endif //GL_ATTRIB_ARRAY_SIZE_NV
#ifndef GL_ATTRIB_ARRAY_STRIDE_NV
#define GL_ATTRIB_ARRAY_STRIDE_NV                                       0x8624
#endif //GL_ATTRIB_ARRAY_STRIDE_NV
#ifndef GL_ATTRIB_ARRAY_TYPE_NV
#define GL_ATTRIB_ARRAY_TYPE_NV                                         0x8625
#endif //GL_ATTRIB_ARRAY_TYPE_NV
#ifndef GL_CURRENT_ATTRIB_NV
#define GL_CURRENT_ATTRIB_NV                                            0x8626
#endif //GL_CURRENT_ATTRIB_NV
#ifndef GL_PROGRAM_LENGTH_NV
#define GL_PROGRAM_LENGTH_NV                                            0x8627
#endif //GL_PROGRAM_LENGTH_NV
#ifndef GL_PROGRAM_STRING_NV
#define GL_PROGRAM_STRING_NV                                            0x8628
#endif //GL_PROGRAM_STRING_NV
#ifndef GL_MODELVIEW_PROJECTION_NV
#define GL_MODELVIEW_PROJECTION_NV                                      0x8629
#endif //GL_MODELVIEW_PROJECTION_NV
#ifndef GL_IDENTITY_NV
#define GL_IDENTITY_NV                                                  0x862A
#endif //GL_IDENTITY_NV
#ifndef GL_INVERSE_NV
#define GL_INVERSE_NV                                                   0x862B
#endif //GL_INVERSE_NV
#ifndef GL_TRANSPOSE_NV
#define GL_TRANSPOSE_NV                                                 0x862C
#endif //GL_TRANSPOSE_NV
#ifndef GL_INVERSE_TRANSPOSE_NV
#define GL_INVERSE_TRANSPOSE_NV                                         0x862D
#endif //GL_INVERSE_TRANSPOSE_NV
#ifndef GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV
#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV                              0x862E
#endif //GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV
#ifndef GL_MAX_TRACK_MATRICES_NV
#define GL_MAX_TRACK_MATRICES_NV                                        0x862F
#endif //GL_MAX_TRACK_MATRICES_NV
#ifndef GL_MATRIX0_NV
#define GL_MATRIX0_NV                                                   0x8630
#endif //GL_MATRIX0_NV
#ifndef GL_MATRIX1_NV
#define GL_MATRIX1_NV                                                   0x8631
#endif //GL_MATRIX1_NV
#ifndef GL_MATRIX2_NV
#define GL_MATRIX2_NV                                                   0x8632
#endif //GL_MATRIX2_NV
#ifndef GL_MATRIX3_NV
#define GL_MATRIX3_NV                                                   0x8633
#endif //GL_MATRIX3_NV
#ifndef GL_MATRIX4_NV
#define GL_MATRIX4_NV                                                   0x8634
#endif //GL_MATRIX4_NV
#ifndef GL_MATRIX5_NV
#define GL_MATRIX5_NV                                                   0x8635
#endif //GL_MATRIX5_NV
#ifndef GL_MATRIX6_NV
#define GL_MATRIX6_NV                                                   0x8636
#endif //GL_MATRIX6_NV
#ifndef GL_MATRIX7_NV
#define GL_MATRIX7_NV                                                   0x8637
#endif //GL_MATRIX7_NV
#ifndef GL_CURRENT_MATRIX_STACK_DEPTH_NV
#define GL_CURRENT_MATRIX_STACK_DEPTH_NV                                0x8640
#endif //GL_CURRENT_MATRIX_STACK_DEPTH_NV
#ifndef GL_CURRENT_MATRIX_NV
#define GL_CURRENT_MATRIX_NV                                            0x8641
#endif //GL_CURRENT_MATRIX_NV
#ifndef GL_VERTEX_PROGRAM_POINT_SIZE_NV
#define GL_VERTEX_PROGRAM_POINT_SIZE_NV                                 0x8642
#endif //GL_VERTEX_PROGRAM_POINT_SIZE_NV
#ifndef GL_VERTEX_PROGRAM_TWO_SIDE_NV
#define GL_VERTEX_PROGRAM_TWO_SIDE_NV                                   0x8643
#endif //GL_VERTEX_PROGRAM_TWO_SIDE_NV
#ifndef GL_PROGRAM_PARAMETER_NV
#define GL_PROGRAM_PARAMETER_NV                                         0x8644
#endif //GL_PROGRAM_PARAMETER_NV
#ifndef GL_ATTRIB_ARRAY_POINTER_NV
#define GL_ATTRIB_ARRAY_POINTER_NV                                      0x8645
#endif //GL_ATTRIB_ARRAY_POINTER_NV
#ifndef GL_PROGRAM_TARGET_NV
#define GL_PROGRAM_TARGET_NV                                            0x8646
#endif //GL_PROGRAM_TARGET_NV
#ifndef GL_PROGRAM_RESIDENT_NV
#define GL_PROGRAM_RESIDENT_NV                                          0x8647
#endif //GL_PROGRAM_RESIDENT_NV
#ifndef GL_TRACK_MATRIX_NV
#define GL_TRACK_MATRIX_NV                                              0x8648
#endif //GL_TRACK_MATRIX_NV
#ifndef GL_TRACK_MATRIX_TRANSFORM_NV
#define GL_TRACK_MATRIX_TRANSFORM_NV                                    0x8649
#endif //GL_TRACK_MATRIX_TRANSFORM_NV
#ifndef GL_VERTEX_PROGRAM_BINDING_NV
#define GL_VERTEX_PROGRAM_BINDING_NV                                    0x864A
#endif //GL_VERTEX_PROGRAM_BINDING_NV
#ifndef GL_PROGRAM_ERROR_POSITION_NV
#define GL_PROGRAM_ERROR_POSITION_NV                                    0x864B
#endif //GL_PROGRAM_ERROR_POSITION_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY0_NV
#define GL_VERTEX_ATTRIB_ARRAY0_NV                                      0x8650
#endif //GL_VERTEX_ATTRIB_ARRAY0_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY1_NV
#define GL_VERTEX_ATTRIB_ARRAY1_NV                                      0x8651
#endif //GL_VERTEX_ATTRIB_ARRAY1_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY2_NV
#define GL_VERTEX_ATTRIB_ARRAY2_NV                                      0x8652
#endif //GL_VERTEX_ATTRIB_ARRAY2_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY3_NV
#define GL_VERTEX_ATTRIB_ARRAY3_NV                                      0x8653
#endif //GL_VERTEX_ATTRIB_ARRAY3_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY4_NV
#define GL_VERTEX_ATTRIB_ARRAY4_NV                                      0x8654
#endif //GL_VERTEX_ATTRIB_ARRAY4_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY5_NV
#define GL_VERTEX_ATTRIB_ARRAY5_NV                                      0x8655
#endif //GL_VERTEX_ATTRIB_ARRAY5_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY6_NV
#define GL_VERTEX_ATTRIB_ARRAY6_NV                                      0x8656
#endif //GL_VERTEX_ATTRIB_ARRAY6_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY7_NV
#define GL_VERTEX_ATTRIB_ARRAY7_NV                                      0x8657
#endif //GL_VERTEX_ATTRIB_ARRAY7_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY8_NV
#define GL_VERTEX_ATTRIB_ARRAY8_NV                                      0x8658
#endif //GL_VERTEX_ATTRIB_ARRAY8_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY9_NV
#define GL_VERTEX_ATTRIB_ARRAY9_NV                                      0x8659
#endif //GL_VERTEX_ATTRIB_ARRAY9_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY10_NV
#define GL_VERTEX_ATTRIB_ARRAY10_NV                                     0x865A
#endif //GL_VERTEX_ATTRIB_ARRAY10_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY11_NV
#define GL_VERTEX_ATTRIB_ARRAY11_NV                                     0x865B
#endif //GL_VERTEX_ATTRIB_ARRAY11_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY12_NV
#define GL_VERTEX_ATTRIB_ARRAY12_NV                                     0x865C
#endif //GL_VERTEX_ATTRIB_ARRAY12_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY13_NV
#define GL_VERTEX_ATTRIB_ARRAY13_NV                                     0x865D
#endif //GL_VERTEX_ATTRIB_ARRAY13_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY14_NV
#define GL_VERTEX_ATTRIB_ARRAY14_NV                                     0x865E
#endif //GL_VERTEX_ATTRIB_ARRAY14_NV
#ifndef GL_VERTEX_ATTRIB_ARRAY15_NV
#define GL_VERTEX_ATTRIB_ARRAY15_NV                                     0x865F
#endif //GL_VERTEX_ATTRIB_ARRAY15_NV
#ifndef GL_MAP1_VERTEX_ATTRIB0_4_NV
#define GL_MAP1_VERTEX_ATTRIB0_4_NV                                     0x8660
#endif //GL_MAP1_VERTEX_ATTRIB0_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB1_4_NV
#define GL_MAP1_VERTEX_ATTRIB1_4_NV                                     0x8661
#endif //GL_MAP1_VERTEX_ATTRIB1_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB2_4_NV
#define GL_MAP1_VERTEX_ATTRIB2_4_NV                                     0x8662
#endif //GL_MAP1_VERTEX_ATTRIB2_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB3_4_NV
#define GL_MAP1_VERTEX_ATTRIB3_4_NV                                     0x8663
#endif //GL_MAP1_VERTEX_ATTRIB3_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB4_4_NV
#define GL_MAP1_VERTEX_ATTRIB4_4_NV                                     0x8664
#endif //GL_MAP1_VERTEX_ATTRIB4_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB5_4_NV
#define GL_MAP1_VERTEX_ATTRIB5_4_NV                                     0x8665
#endif //GL_MAP1_VERTEX_ATTRIB5_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB6_4_NV
#define GL_MAP1_VERTEX_ATTRIB6_4_NV                                     0x8666
#endif //GL_MAP1_VERTEX_ATTRIB6_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB7_4_NV
#define GL_MAP1_VERTEX_ATTRIB7_4_NV                                     0x8667
#endif //GL_MAP1_VERTEX_ATTRIB7_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB8_4_NV
#define GL_MAP1_VERTEX_ATTRIB8_4_NV                                     0x8668
#endif //GL_MAP1_VERTEX_ATTRIB8_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB9_4_NV
#define GL_MAP1_VERTEX_ATTRIB9_4_NV                                     0x8669
#endif //GL_MAP1_VERTEX_ATTRIB9_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB10_4_NV
#define GL_MAP1_VERTEX_ATTRIB10_4_NV                                    0x866A
#endif //GL_MAP1_VERTEX_ATTRIB10_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB11_4_NV
#define GL_MAP1_VERTEX_ATTRIB11_4_NV                                    0x866B
#endif //GL_MAP1_VERTEX_ATTRIB11_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB12_4_NV
#define GL_MAP1_VERTEX_ATTRIB12_4_NV                                    0x866C
#endif //GL_MAP1_VERTEX_ATTRIB12_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB13_4_NV
#define GL_MAP1_VERTEX_ATTRIB13_4_NV                                    0x866D
#endif //GL_MAP1_VERTEX_ATTRIB13_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB14_4_NV
#define GL_MAP1_VERTEX_ATTRIB14_4_NV                                    0x866E
#endif //GL_MAP1_VERTEX_ATTRIB14_4_NV
#ifndef GL_MAP1_VERTEX_ATTRIB15_4_NV
#define GL_MAP1_VERTEX_ATTRIB15_4_NV                                    0x866F
#endif //GL_MAP1_VERTEX_ATTRIB15_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB0_4_NV
#define GL_MAP2_VERTEX_ATTRIB0_4_NV                                     0x8670
#endif //GL_MAP2_VERTEX_ATTRIB0_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB1_4_NV
#define GL_MAP2_VERTEX_ATTRIB1_4_NV                                     0x8671
#endif //GL_MAP2_VERTEX_ATTRIB1_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB2_4_NV
#define GL_MAP2_VERTEX_ATTRIB2_4_NV                                     0x8672
#endif //GL_MAP2_VERTEX_ATTRIB2_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB3_4_NV
#define GL_MAP2_VERTEX_ATTRIB3_4_NV                                     0x8673
#endif //GL_MAP2_VERTEX_ATTRIB3_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB4_4_NV
#define GL_MAP2_VERTEX_ATTRIB4_4_NV                                     0x8674
#endif //GL_MAP2_VERTEX_ATTRIB4_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB5_4_NV
#define GL_MAP2_VERTEX_ATTRIB5_4_NV                                     0x8675
#endif //GL_MAP2_VERTEX_ATTRIB5_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB6_4_NV
#define GL_MAP2_VERTEX_ATTRIB6_4_NV                                     0x8676
#endif //GL_MAP2_VERTEX_ATTRIB6_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB7_4_NV
#define GL_MAP2_VERTEX_ATTRIB7_4_NV                                     0x8677
#endif //GL_MAP2_VERTEX_ATTRIB7_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB8_4_NV
#define GL_MAP2_VERTEX_ATTRIB8_4_NV                                     0x8678
#endif //GL_MAP2_VERTEX_ATTRIB8_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB9_4_NV
#define GL_MAP2_VERTEX_ATTRIB9_4_NV                                     0x8679
#endif //GL_MAP2_VERTEX_ATTRIB9_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB10_4_NV
#define GL_MAP2_VERTEX_ATTRIB10_4_NV                                    0x867A
#endif //GL_MAP2_VERTEX_ATTRIB10_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB11_4_NV
#define GL_MAP2_VERTEX_ATTRIB11_4_NV                                    0x867B
#endif //GL_MAP2_VERTEX_ATTRIB11_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB12_4_NV
#define GL_MAP2_VERTEX_ATTRIB12_4_NV                                    0x867C
#endif //GL_MAP2_VERTEX_ATTRIB12_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB13_4_NV
#define GL_MAP2_VERTEX_ATTRIB13_4_NV                                    0x867D
#endif //GL_MAP2_VERTEX_ATTRIB13_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB14_4_NV
#define GL_MAP2_VERTEX_ATTRIB14_4_NV                                    0x867E
#endif //GL_MAP2_VERTEX_ATTRIB14_4_NV
#ifndef GL_MAP2_VERTEX_ATTRIB15_4_NV
#define GL_MAP2_VERTEX_ATTRIB15_4_NV                                    0x867F
#endif //GL_MAP2_VERTEX_ATTRIB15_4_NV

#endif //GL_NV_vertex_program


typedef GLboolean (*PFNAREPROGRAMSRESIDENTNVPROC_HPP)(GLsizei n,const GLuint *programs,GLboolean *residences);

static inline GLboolean AreProgramsResidentNV(GLsizei n,const GLuint *programs,GLboolean *residences)
{
	static PFNAREPROGRAMSRESIDENTNVPROC_HPP fn=reinterpret_cast<PFNAREPROGRAMSRESIDENTNVPROC_HPP>(_impl::_get_proc_address("glAreProgramsResidentNV","GL_NV_vertex_program"));
	return fn(n,programs,residences);
}

typedef void (*PFNBINDPROGRAMNVPROC_HPP)(GLenum target,GLuint id);

static inline void BindProgramNV(GLenum target,GLuint id)
{
	static PFNBINDPROGRAMNVPROC_HPP fn=reinterpret_cast<PFNBINDPROGRAMNVPROC_HPP>(_impl::_get_proc_address("glBindProgramNV","GL_NV_vertex_program"));
	 fn(target,id);
}

typedef void (*PFNDELETEPROGRAMSNVPROC_HPP)(GLsizei n,const GLuint *programs);

static inline void DeleteProgramsNV(GLsizei n,const GLuint *programs)
{
	static PFNDELETEPROGRAMSNVPROC_HPP fn=reinterpret_cast<PFNDELETEPROGRAMSNVPROC_HPP>(_impl::_get_proc_address("glDeleteProgramsNV","GL_NV_vertex_program"));
	 fn(n,programs);
}

typedef void (*PFNEXECUTEPROGRAMNVPROC_HPP)(GLenum target,GLuint id,const GLfloat *params);

static inline void ExecuteProgramNV(GLenum target,GLuint id,const GLfloat *params)
{
	static PFNEXECUTEPROGRAMNVPROC_HPP fn=reinterpret_cast<PFNEXECUTEPROGRAMNVPROC_HPP>(_impl::_get_proc_address("glExecuteProgramNV","GL_NV_vertex_program"));
	 fn(target,id,params);
}

typedef void (*PFNGENPROGRAMSNVPROC_HPP)(GLsizei n,GLuint *programs);

static inline void GenProgramsNV(GLsizei n,GLuint *programs)
{
	static PFNGENPROGRAMSNVPROC_HPP fn=reinterpret_cast<PFNGENPROGRAMSNVPROC_HPP>(_impl::_get_proc_address("glGenProgramsNV","GL_NV_vertex_program"));
	 fn(n,programs);
}

typedef void (*PFNGETPROGRAMPARAMETERDVNVPROC_HPP)(GLenum target,GLuint index,GLenum pname,GLdouble *params);

static inline void GetProgramParameterdvNV(GLenum target,GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETPROGRAMPARAMETERDVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMPARAMETERDVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramParameterdvNV","GL_NV_vertex_program"));
	 fn(target,index,pname,params);
}

typedef void (*PFNGETPROGRAMPARAMETERFVNVPROC_HPP)(GLenum target,GLuint index,GLenum pname,GLfloat *params);

static inline void GetProgramParameterfvNV(GLenum target,GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETPROGRAMPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramParameterfvNV","GL_NV_vertex_program"));
	 fn(target,index,pname,params);
}

typedef void (*PFNGETPROGRAMIVNVPROC_HPP)(GLuint id,GLenum pname,GLint *params);

static inline void GetProgramivNV(GLuint id,GLenum pname,GLint *params)
{
	static PFNGETPROGRAMIVNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMIVNVPROC_HPP>(_impl::_get_proc_address("glGetProgramivNV","GL_NV_vertex_program"));
	 fn(id,pname,params);
}

typedef void (*PFNGETPROGRAMSTRINGNVPROC_HPP)(GLuint id,GLenum pname,GLubyte *program);

static inline void GetProgramStringNV(GLuint id,GLenum pname,GLubyte *program)
{
	static PFNGETPROGRAMSTRINGNVPROC_HPP fn=reinterpret_cast<PFNGETPROGRAMSTRINGNVPROC_HPP>(_impl::_get_proc_address("glGetProgramStringNV","GL_NV_vertex_program"));
	 fn(id,pname,program);
}

typedef void (*PFNGETTRACKMATRIXIVNVPROC_HPP)(GLenum target,GLuint address,GLenum pname,GLint *params);

static inline void GetTrackMatrixivNV(GLenum target,GLuint address,GLenum pname,GLint *params)
{
	static PFNGETTRACKMATRIXIVNVPROC_HPP fn=reinterpret_cast<PFNGETTRACKMATRIXIVNVPROC_HPP>(_impl::_get_proc_address("glGetTrackMatrixivNV","GL_NV_vertex_program"));
	 fn(target,address,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBDVNVPROC_HPP)(GLuint index,GLenum pname,GLdouble *params);

static inline void GetVertexAttribdvNV(GLuint index,GLenum pname,GLdouble *params)
{
	static PFNGETVERTEXATTRIBDVNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBDVNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribdvNV","GL_NV_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBFVNVPROC_HPP)(GLuint index,GLenum pname,GLfloat *params);

static inline void GetVertexAttribfvNV(GLuint index,GLenum pname,GLfloat *params)
{
	static PFNGETVERTEXATTRIBFVNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBFVNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribfvNV","GL_NV_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBIVNVPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribivNV(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBIVNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIVNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribivNV","GL_NV_vertex_program"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBPOINTERVNVPROC_HPP)(GLuint index,GLenum pname,GLvoid* *pointer);

static inline void GetVertexAttribPointervNV(GLuint index,GLenum pname,GLvoid* *pointer)
{
	static PFNGETVERTEXATTRIBPOINTERVNVPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBPOINTERVNVPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribPointervNV","GL_NV_vertex_program"));
	 fn(index,pname,pointer);
}

typedef GLboolean (*PFNISPROGRAMNVPROC_HPP)(GLuint id);

static inline GLboolean IsProgramNV(GLuint id)
{
	static PFNISPROGRAMNVPROC_HPP fn=reinterpret_cast<PFNISPROGRAMNVPROC_HPP>(_impl::_get_proc_address("glIsProgramNV","GL_NV_vertex_program"));
	return fn(id);
}

typedef void (*PFNLOADPROGRAMNVPROC_HPP)(GLenum target,GLuint id,GLsizei len,const GLubyte *program);

static inline void LoadProgramNV(GLenum target,GLuint id,GLsizei len,const GLubyte *program)
{
	static PFNLOADPROGRAMNVPROC_HPP fn=reinterpret_cast<PFNLOADPROGRAMNVPROC_HPP>(_impl::_get_proc_address("glLoadProgramNV","GL_NV_vertex_program"));
	 fn(target,id,len,program);
}

typedef void (*PFNPROGRAMPARAMETER4DNVPROC_HPP)(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void ProgramParameter4dNV(GLenum target,GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNPROGRAMPARAMETER4DNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETER4DNVPROC_HPP>(_impl::_get_proc_address("glProgramParameter4dNV","GL_NV_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMPARAMETER4DVNVPROC_HPP)(GLenum target,GLuint index,const GLdouble *v);

static inline void ProgramParameter4dvNV(GLenum target,GLuint index,const GLdouble *v)
{
	static PFNPROGRAMPARAMETER4DVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETER4DVNVPROC_HPP>(_impl::_get_proc_address("glProgramParameter4dvNV","GL_NV_vertex_program"));
	 fn(target,index,v);
}

typedef void (*PFNPROGRAMPARAMETER4FNVPROC_HPP)(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void ProgramParameter4fNV(GLenum target,GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNPROGRAMPARAMETER4FNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETER4FNVPROC_HPP>(_impl::_get_proc_address("glProgramParameter4fNV","GL_NV_vertex_program"));
	 fn(target,index,x,y,z,w);
}

typedef void (*PFNPROGRAMPARAMETER4FVNVPROC_HPP)(GLenum target,GLuint index,const GLfloat *v);

static inline void ProgramParameter4fvNV(GLenum target,GLuint index,const GLfloat *v)
{
	static PFNPROGRAMPARAMETER4FVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETER4FVNVPROC_HPP>(_impl::_get_proc_address("glProgramParameter4fvNV","GL_NV_vertex_program"));
	 fn(target,index,v);
}

typedef void (*PFNPROGRAMPARAMETERS4DVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLdouble *v);

static inline void ProgramParameters4dvNV(GLenum target,GLuint index,GLsizei count,const GLdouble *v)
{
	static PFNPROGRAMPARAMETERS4DVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETERS4DVNVPROC_HPP>(_impl::_get_proc_address("glProgramParameters4dvNV","GL_NV_vertex_program"));
	 fn(target,index,count,v);
}

typedef void (*PFNPROGRAMPARAMETERS4FVNVPROC_HPP)(GLenum target,GLuint index,GLsizei count,const GLfloat *v);

static inline void ProgramParameters4fvNV(GLenum target,GLuint index,GLsizei count,const GLfloat *v)
{
	static PFNPROGRAMPARAMETERS4FVNVPROC_HPP fn=reinterpret_cast<PFNPROGRAMPARAMETERS4FVNVPROC_HPP>(_impl::_get_proc_address("glProgramParameters4fvNV","GL_NV_vertex_program"));
	 fn(target,index,count,v);
}

typedef void (*PFNREQUESTRESIDENTPROGRAMSNVPROC_HPP)(GLsizei n,const GLuint *programs);

static inline void RequestResidentProgramsNV(GLsizei n,const GLuint *programs)
{
	static PFNREQUESTRESIDENTPROGRAMSNVPROC_HPP fn=reinterpret_cast<PFNREQUESTRESIDENTPROGRAMSNVPROC_HPP>(_impl::_get_proc_address("glRequestResidentProgramsNV","GL_NV_vertex_program"));
	 fn(n,programs);
}

typedef void (*PFNTRACKMATRIXNVPROC_HPP)(GLenum target,GLuint address,GLenum matrix,GLenum transform);

static inline void TrackMatrixNV(GLenum target,GLuint address,GLenum matrix,GLenum transform)
{
	static PFNTRACKMATRIXNVPROC_HPP fn=reinterpret_cast<PFNTRACKMATRIXNVPROC_HPP>(_impl::_get_proc_address("glTrackMatrixNV","GL_NV_vertex_program"));
	 fn(target,address,matrix,transform);
}

typedef void (*PFNVERTEXATTRIBPOINTERNVPROC_HPP)(GLuint index,GLint fsize,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribPointerNV(GLuint index,GLint fsize,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBPOINTERNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBPOINTERNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribPointerNV","GL_NV_vertex_program"));
	 fn(index,fsize,type,stride,pointer);
}

typedef void (*PFNVERTEXATTRIB1DNVPROC_HPP)(GLuint index,GLdouble x);

static inline void VertexAttrib1dNV(GLuint index,GLdouble x)
{
	static PFNVERTEXATTRIB1DNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1dNV","GL_NV_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1DVNVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib1dvNV(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB1DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1dvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1FNVPROC_HPP)(GLuint index,GLfloat x);

static inline void VertexAttrib1fNV(GLuint index,GLfloat x)
{
	static PFNVERTEXATTRIB1FNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1fNV","GL_NV_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1FVNVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib1fvNV(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB1FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1fvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB1SNVPROC_HPP)(GLuint index,GLshort x);

static inline void VertexAttrib1sNV(GLuint index,GLshort x)
{
	static PFNVERTEXATTRIB1SNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1sNV","GL_NV_vertex_program"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIB1SVNVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib1svNV(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB1SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB1SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib1svNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2DNVPROC_HPP)(GLuint index,GLdouble x,GLdouble y);

static inline void VertexAttrib2dNV(GLuint index,GLdouble x,GLdouble y)
{
	static PFNVERTEXATTRIB2DNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2dNV","GL_NV_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2DVNVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib2dvNV(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB2DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2dvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2FNVPROC_HPP)(GLuint index,GLfloat x,GLfloat y);

static inline void VertexAttrib2fNV(GLuint index,GLfloat x,GLfloat y)
{
	static PFNVERTEXATTRIB2FNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2fNV","GL_NV_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2FVNVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib2fvNV(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB2FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2fvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB2SNVPROC_HPP)(GLuint index,GLshort x,GLshort y);

static inline void VertexAttrib2sNV(GLuint index,GLshort x,GLshort y)
{
	static PFNVERTEXATTRIB2SNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2sNV","GL_NV_vertex_program"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIB2SVNVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib2svNV(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB2SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB2SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib2svNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3DNVPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z);

static inline void VertexAttrib3dNV(GLuint index,GLdouble x,GLdouble y,GLdouble z)
{
	static PFNVERTEXATTRIB3DNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3dNV","GL_NV_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3DVNVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib3dvNV(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB3DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3dvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3FNVPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z);

static inline void VertexAttrib3fNV(GLuint index,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNVERTEXATTRIB3FNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3fNV","GL_NV_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3FVNVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib3fvNV(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB3FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3fvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB3SNVPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z);

static inline void VertexAttrib3sNV(GLuint index,GLshort x,GLshort y,GLshort z)
{
	static PFNVERTEXATTRIB3SNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3sNV","GL_NV_vertex_program"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIB3SVNVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib3svNV(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB3SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB3SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib3svNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4DNVPROC_HPP)(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w);

static inline void VertexAttrib4dNV(GLuint index,GLdouble x,GLdouble y,GLdouble z,GLdouble w)
{
	static PFNVERTEXATTRIB4DNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4dNV","GL_NV_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4DVNVPROC_HPP)(GLuint index,const GLdouble *v);

static inline void VertexAttrib4dvNV(GLuint index,const GLdouble *v)
{
	static PFNVERTEXATTRIB4DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4dvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4FNVPROC_HPP)(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void VertexAttrib4fNV(GLuint index,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNVERTEXATTRIB4FNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4fNV","GL_NV_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4FVNVPROC_HPP)(GLuint index,const GLfloat *v);

static inline void VertexAttrib4fvNV(GLuint index,const GLfloat *v)
{
	static PFNVERTEXATTRIB4FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4fvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4SNVPROC_HPP)(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w);

static inline void VertexAttrib4sNV(GLuint index,GLshort x,GLshort y,GLshort z,GLshort w)
{
	static PFNVERTEXATTRIB4SNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4sNV","GL_NV_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4SVNVPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttrib4svNV(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIB4SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4svNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIB4UBNVPROC_HPP)(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w);

static inline void VertexAttrib4ubNV(GLuint index,GLubyte x,GLubyte y,GLubyte z,GLubyte w)
{
	static PFNVERTEXATTRIB4UBNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UBNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4ubNV","GL_NV_vertex_program"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIB4UBVNVPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttrib4ubvNV(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIB4UBVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIB4UBVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttrib4ubvNV","GL_NV_vertex_program"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBS1DVNVPROC_HPP)(GLuint index,GLsizei count,const GLdouble *v);

static inline void VertexAttribs1dvNV(GLuint index,GLsizei count,const GLdouble *v)
{
	static PFNVERTEXATTRIBS1DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS1DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs1dvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS1FVNVPROC_HPP)(GLuint index,GLsizei count,const GLfloat *v);

static inline void VertexAttribs1fvNV(GLuint index,GLsizei count,const GLfloat *v)
{
	static PFNVERTEXATTRIBS1FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS1FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs1fvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS1SVNVPROC_HPP)(GLuint index,GLsizei count,const GLshort *v);

static inline void VertexAttribs1svNV(GLuint index,GLsizei count,const GLshort *v)
{
	static PFNVERTEXATTRIBS1SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS1SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs1svNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS2DVNVPROC_HPP)(GLuint index,GLsizei count,const GLdouble *v);

static inline void VertexAttribs2dvNV(GLuint index,GLsizei count,const GLdouble *v)
{
	static PFNVERTEXATTRIBS2DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS2DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs2dvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS2FVNVPROC_HPP)(GLuint index,GLsizei count,const GLfloat *v);

static inline void VertexAttribs2fvNV(GLuint index,GLsizei count,const GLfloat *v)
{
	static PFNVERTEXATTRIBS2FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS2FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs2fvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS2SVNVPROC_HPP)(GLuint index,GLsizei count,const GLshort *v);

static inline void VertexAttribs2svNV(GLuint index,GLsizei count,const GLshort *v)
{
	static PFNVERTEXATTRIBS2SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS2SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs2svNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS3DVNVPROC_HPP)(GLuint index,GLsizei count,const GLdouble *v);

static inline void VertexAttribs3dvNV(GLuint index,GLsizei count,const GLdouble *v)
{
	static PFNVERTEXATTRIBS3DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS3DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs3dvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS3FVNVPROC_HPP)(GLuint index,GLsizei count,const GLfloat *v);

static inline void VertexAttribs3fvNV(GLuint index,GLsizei count,const GLfloat *v)
{
	static PFNVERTEXATTRIBS3FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS3FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs3fvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS3SVNVPROC_HPP)(GLuint index,GLsizei count,const GLshort *v);

static inline void VertexAttribs3svNV(GLuint index,GLsizei count,const GLshort *v)
{
	static PFNVERTEXATTRIBS3SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS3SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs3svNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS4DVNVPROC_HPP)(GLuint index,GLsizei count,const GLdouble *v);

static inline void VertexAttribs4dvNV(GLuint index,GLsizei count,const GLdouble *v)
{
	static PFNVERTEXATTRIBS4DVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS4DVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs4dvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS4FVNVPROC_HPP)(GLuint index,GLsizei count,const GLfloat *v);

static inline void VertexAttribs4fvNV(GLuint index,GLsizei count,const GLfloat *v)
{
	static PFNVERTEXATTRIBS4FVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS4FVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs4fvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS4SVNVPROC_HPP)(GLuint index,GLsizei count,const GLshort *v);

static inline void VertexAttribs4svNV(GLuint index,GLsizei count,const GLshort *v)
{
	static PFNVERTEXATTRIBS4SVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS4SVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs4svNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}

typedef void (*PFNVERTEXATTRIBS4UBVNVPROC_HPP)(GLuint index,GLsizei count,const GLubyte *v);

static inline void VertexAttribs4ubvNV(GLuint index,GLsizei count,const GLubyte *v)
{
	static PFNVERTEXATTRIBS4UBVNVPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBS4UBVNVPROC_HPP>(_impl::_get_proc_address("glVertexAttribs4ubvNV","GL_NV_vertex_program"));
	 fn(index,count,v);
}
#ifndef GL_NV_vertex_program2_option

#define GL_NV_vertex_program2_option

#endif //GL_NV_vertex_program2_option

#ifndef GL_NV_vertex_program3

#define GL_NV_vertex_program3
#ifndef GL_FRAGMENT_SHADER
#define GL_FRAGMENT_SHADER                                              0x8B30
#endif //GL_FRAGMENT_SHADER
#ifndef GL_FRAGMENT_SHADER_ARB
#define GL_FRAGMENT_SHADER_ARB                                          0x8B30
#endif //GL_FRAGMENT_SHADER_ARB
#ifndef GL_VERTEX_SHADER
#define GL_VERTEX_SHADER                                                0x8B31
#endif //GL_VERTEX_SHADER
#ifndef GL_VERTEX_SHADER_ARB
#define GL_VERTEX_SHADER_ARB                                            0x8B31
#endif //GL_VERTEX_SHADER_ARB
#ifndef GL_PROGRAM_OBJECT_ARB
#define GL_PROGRAM_OBJECT_ARB                                           0x8B40
#endif //GL_PROGRAM_OBJECT_ARB
#ifndef GL_SHADER_OBJECT_ARB
#define GL_SHADER_OBJECT_ARB                                            0x8B48
#endif //GL_SHADER_OBJECT_ARB
#ifndef GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB                          0x8B49
#endif //GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
#ifndef GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS                              0x8B49
#endif //GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
#ifndef GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB                            0x8B4A
#endif //GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
#ifndef GL_MAX_VERTEX_UNIFORM_COMPONENTS
#define GL_MAX_VERTEX_UNIFORM_COMPONENTS                                0x8B4A
#endif //GL_MAX_VERTEX_UNIFORM_COMPONENTS
#ifndef GL_MAX_VARYING_FLOATS_ARB
#define GL_MAX_VARYING_FLOATS_ARB                                       0x8B4B
#endif //GL_MAX_VARYING_FLOATS_ARB
#ifndef GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB                           0x8B4C
#endif //GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
#ifndef GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS                               0x8B4C
#endif //GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
#ifndef GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS                             0x8B4D
#endif //GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
#ifndef GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB                         0x8B4D
#endif //GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
#ifndef GL_OBJECT_TYPE_ARB
#define GL_OBJECT_TYPE_ARB                                              0x8B4E
#endif //GL_OBJECT_TYPE_ARB
#ifndef GL_SHADER_TYPE
#define GL_SHADER_TYPE                                                  0x8B4F
#endif //GL_SHADER_TYPE
#ifndef GL_OBJECT_SUBTYPE_ARB
#define GL_OBJECT_SUBTYPE_ARB                                           0x8B4F
#endif //GL_OBJECT_SUBTYPE_ARB
#ifndef GL_FLOAT_VEC2_ARB
#define GL_FLOAT_VEC2_ARB                                               0x8B50
#endif //GL_FLOAT_VEC2_ARB
#ifndef GL_FLOAT_VEC2
#define GL_FLOAT_VEC2                                                   0x8B50
#endif //GL_FLOAT_VEC2
#ifndef GL_FLOAT_VEC3
#define GL_FLOAT_VEC3                                                   0x8B51
#endif //GL_FLOAT_VEC3
#ifndef GL_FLOAT_VEC3_ARB
#define GL_FLOAT_VEC3_ARB                                               0x8B51
#endif //GL_FLOAT_VEC3_ARB
#ifndef GL_FLOAT_VEC4_ARB
#define GL_FLOAT_VEC4_ARB                                               0x8B52
#endif //GL_FLOAT_VEC4_ARB
#ifndef GL_FLOAT_VEC4
#define GL_FLOAT_VEC4                                                   0x8B52
#endif //GL_FLOAT_VEC4
#ifndef GL_INT_VEC2_ARB
#define GL_INT_VEC2_ARB                                                 0x8B53
#endif //GL_INT_VEC2_ARB
#ifndef GL_INT_VEC2
#define GL_INT_VEC2                                                     0x8B53
#endif //GL_INT_VEC2
#ifndef GL_INT_VEC3
#define GL_INT_VEC3                                                     0x8B54
#endif //GL_INT_VEC3
#ifndef GL_INT_VEC3_ARB
#define GL_INT_VEC3_ARB                                                 0x8B54
#endif //GL_INT_VEC3_ARB
#ifndef GL_INT_VEC4
#define GL_INT_VEC4                                                     0x8B55
#endif //GL_INT_VEC4
#ifndef GL_INT_VEC4_ARB
#define GL_INT_VEC4_ARB                                                 0x8B55
#endif //GL_INT_VEC4_ARB
#ifndef GL_BOOL
#define GL_BOOL                                                         0x8B56
#endif //GL_BOOL
#ifndef GL_BOOL_ARB
#define GL_BOOL_ARB                                                     0x8B56
#endif //GL_BOOL_ARB
#ifndef GL_BOOL_VEC2_ARB
#define GL_BOOL_VEC2_ARB                                                0x8B57
#endif //GL_BOOL_VEC2_ARB
#ifndef GL_BOOL_VEC2
#define GL_BOOL_VEC2                                                    0x8B57
#endif //GL_BOOL_VEC2
#ifndef GL_BOOL_VEC3_ARB
#define GL_BOOL_VEC3_ARB                                                0x8B58
#endif //GL_BOOL_VEC3_ARB
#ifndef GL_BOOL_VEC3
#define GL_BOOL_VEC3                                                    0x8B58
#endif //GL_BOOL_VEC3
#ifndef GL_BOOL_VEC4_ARB
#define GL_BOOL_VEC4_ARB                                                0x8B59
#endif //GL_BOOL_VEC4_ARB
#ifndef GL_BOOL_VEC4
#define GL_BOOL_VEC4                                                    0x8B59
#endif //GL_BOOL_VEC4
#ifndef GL_FLOAT_MAT2_ARB
#define GL_FLOAT_MAT2_ARB                                               0x8B5A
#endif //GL_FLOAT_MAT2_ARB
#ifndef GL_FLOAT_MAT2
#define GL_FLOAT_MAT2                                                   0x8B5A
#endif //GL_FLOAT_MAT2
#ifndef GL_FLOAT_MAT3_ARB
#define GL_FLOAT_MAT3_ARB                                               0x8B5B
#endif //GL_FLOAT_MAT3_ARB
#ifndef GL_FLOAT_MAT3
#define GL_FLOAT_MAT3                                                   0x8B5B
#endif //GL_FLOAT_MAT3
#ifndef GL_FLOAT_MAT4
#define GL_FLOAT_MAT4                                                   0x8B5C
#endif //GL_FLOAT_MAT4
#ifndef GL_FLOAT_MAT4_ARB
#define GL_FLOAT_MAT4_ARB                                               0x8B5C
#endif //GL_FLOAT_MAT4_ARB
#ifndef GL_SAMPLER_1D
#define GL_SAMPLER_1D                                                   0x8B5D
#endif //GL_SAMPLER_1D
#ifndef GL_SAMPLER_1D_ARB
#define GL_SAMPLER_1D_ARB                                               0x8B5D
#endif //GL_SAMPLER_1D_ARB
#ifndef GL_SAMPLER_2D_ARB
#define GL_SAMPLER_2D_ARB                                               0x8B5E
#endif //GL_SAMPLER_2D_ARB
#ifndef GL_SAMPLER_2D
#define GL_SAMPLER_2D                                                   0x8B5E
#endif //GL_SAMPLER_2D
#ifndef GL_SAMPLER_3D
#define GL_SAMPLER_3D                                                   0x8B5F
#endif //GL_SAMPLER_3D
#ifndef GL_SAMPLER_3D_ARB
#define GL_SAMPLER_3D_ARB                                               0x8B5F
#endif //GL_SAMPLER_3D_ARB
#ifndef GL_SAMPLER_CUBE_ARB
#define GL_SAMPLER_CUBE_ARB                                             0x8B60
#endif //GL_SAMPLER_CUBE_ARB
#ifndef GL_SAMPLER_CUBE
#define GL_SAMPLER_CUBE                                                 0x8B60
#endif //GL_SAMPLER_CUBE
#ifndef GL_SAMPLER_1D_SHADOW
#define GL_SAMPLER_1D_SHADOW                                            0x8B61
#endif //GL_SAMPLER_1D_SHADOW
#ifndef GL_SAMPLER_1D_SHADOW_ARB
#define GL_SAMPLER_1D_SHADOW_ARB                                        0x8B61
#endif //GL_SAMPLER_1D_SHADOW_ARB
#ifndef GL_SAMPLER_2D_SHADOW_ARB
#define GL_SAMPLER_2D_SHADOW_ARB                                        0x8B62
#endif //GL_SAMPLER_2D_SHADOW_ARB
#ifndef GL_SAMPLER_2D_SHADOW
#define GL_SAMPLER_2D_SHADOW                                            0x8B62
#endif //GL_SAMPLER_2D_SHADOW
#ifndef GL_SAMPLER_2D_RECT_ARB
#define GL_SAMPLER_2D_RECT_ARB                                          0x8B63
#endif //GL_SAMPLER_2D_RECT_ARB
#ifndef GL_SAMPLER_2D_RECT_SHADOW_ARB
#define GL_SAMPLER_2D_RECT_SHADOW_ARB                                   0x8B64
#endif //GL_SAMPLER_2D_RECT_SHADOW_ARB
#ifndef GL_FLOAT_MAT2x3
#define GL_FLOAT_MAT2x3                                                 0x8B65
#endif //GL_FLOAT_MAT2x3
#ifndef GL_FLOAT_MAT2x4
#define GL_FLOAT_MAT2x4                                                 0x8B66
#endif //GL_FLOAT_MAT2x4
#ifndef GL_FLOAT_MAT3x2
#define GL_FLOAT_MAT3x2                                                 0x8B67
#endif //GL_FLOAT_MAT3x2
#ifndef GL_FLOAT_MAT3x4
#define GL_FLOAT_MAT3x4                                                 0x8B68
#endif //GL_FLOAT_MAT3x4
#ifndef GL_FLOAT_MAT4x2
#define GL_FLOAT_MAT4x2                                                 0x8B69
#endif //GL_FLOAT_MAT4x2
#ifndef GL_FLOAT_MAT4x3
#define GL_FLOAT_MAT4x3                                                 0x8B6A
#endif //GL_FLOAT_MAT4x3
#ifndef GL_DELETE_STATUS
#define GL_DELETE_STATUS                                                0x8B80
#endif //GL_DELETE_STATUS
#ifndef GL_OBJECT_DELETE_STATUS_ARB
#define GL_OBJECT_DELETE_STATUS_ARB                                     0x8B80
#endif //GL_OBJECT_DELETE_STATUS_ARB
#ifndef GL_OBJECT_COMPILE_STATUS_ARB
#define GL_OBJECT_COMPILE_STATUS_ARB                                    0x8B81
#endif //GL_OBJECT_COMPILE_STATUS_ARB
#ifndef GL_COMPILE_STATUS
#define GL_COMPILE_STATUS                                               0x8B81
#endif //GL_COMPILE_STATUS
#ifndef GL_LINK_STATUS
#define GL_LINK_STATUS                                                  0x8B82
#endif //GL_LINK_STATUS
#ifndef GL_OBJECT_LINK_STATUS_ARB
#define GL_OBJECT_LINK_STATUS_ARB                                       0x8B82
#endif //GL_OBJECT_LINK_STATUS_ARB
#ifndef GL_OBJECT_VALIDATE_STATUS_ARB
#define GL_OBJECT_VALIDATE_STATUS_ARB                                   0x8B83
#endif //GL_OBJECT_VALIDATE_STATUS_ARB
#ifndef GL_VALIDATE_STATUS
#define GL_VALIDATE_STATUS                                              0x8B83
#endif //GL_VALIDATE_STATUS
#ifndef GL_OBJECT_INFO_LOG_LENGTH_ARB
#define GL_OBJECT_INFO_LOG_LENGTH_ARB                                   0x8B84
#endif //GL_OBJECT_INFO_LOG_LENGTH_ARB
#ifndef GL_INFO_LOG_LENGTH
#define GL_INFO_LOG_LENGTH                                              0x8B84
#endif //GL_INFO_LOG_LENGTH
#ifndef GL_ATTACHED_SHADERS
#define GL_ATTACHED_SHADERS                                             0x8B85
#endif //GL_ATTACHED_SHADERS
#ifndef GL_OBJECT_ATTACHED_OBJECTS_ARB
#define GL_OBJECT_ATTACHED_OBJECTS_ARB                                  0x8B85
#endif //GL_OBJECT_ATTACHED_OBJECTS_ARB
#ifndef GL_OBJECT_ACTIVE_UNIFORMS_ARB
#define GL_OBJECT_ACTIVE_UNIFORMS_ARB                                   0x8B86
#endif //GL_OBJECT_ACTIVE_UNIFORMS_ARB
#ifndef GL_ACTIVE_UNIFORMS
#define GL_ACTIVE_UNIFORMS                                              0x8B86
#endif //GL_ACTIVE_UNIFORMS
#ifndef GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB
#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB                         0x8B87
#endif //GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB
#ifndef GL_ACTIVE_UNIFORM_MAX_LENGTH
#define GL_ACTIVE_UNIFORM_MAX_LENGTH                                    0x8B87
#endif //GL_ACTIVE_UNIFORM_MAX_LENGTH
#ifndef GL_OBJECT_SHADER_SOURCE_LENGTH_ARB
#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB                              0x8B88
#endif //GL_OBJECT_SHADER_SOURCE_LENGTH_ARB
#ifndef GL_SHADER_SOURCE_LENGTH
#define GL_SHADER_SOURCE_LENGTH                                         0x8B88
#endif //GL_SHADER_SOURCE_LENGTH
#ifndef GL_ACTIVE_ATTRIBUTES
#define GL_ACTIVE_ATTRIBUTES                                            0x8B89
#endif //GL_ACTIVE_ATTRIBUTES
#ifndef GL_OBJECT_ACTIVE_ATTRIBUTES_ARB
#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB                                 0x8B89
#endif //GL_OBJECT_ACTIVE_ATTRIBUTES_ARB
#ifndef GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB
#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB                       0x8B8A
#endif //GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB
#ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH                                  0x8B8A
#endif //GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
#ifndef GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB                          0x8B8B
#endif //GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
#ifndef GL_FRAGMENT_SHADER_DERIVATIVE_HINT
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT                              0x8B8B
#endif //GL_FRAGMENT_SHADER_DERIVATIVE_HINT
#ifndef GL_SHADING_LANGUAGE_VERSION_ARB
#define GL_SHADING_LANGUAGE_VERSION_ARB                                 0x8B8C
#endif //GL_SHADING_LANGUAGE_VERSION_ARB
#ifndef GL_SHADING_LANGUAGE_VERSION
#define GL_SHADING_LANGUAGE_VERSION                                     0x8B8C
#endif //GL_SHADING_LANGUAGE_VERSION

#endif //GL_NV_vertex_program3

#ifndef GL_NV_vertex_program4

#define GL_NV_vertex_program4
#ifndef GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV
#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV                               0x88FD
#endif //GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV

#endif //GL_NV_vertex_program4


typedef void (*PFNVERTEXATTRIBI1IEXTPROC_HPP)(GLuint index,GLint x);

static inline void VertexAttribI1iEXT(GLuint index,GLint x)
{
	static PFNVERTEXATTRIBI1IEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1IEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1iEXT","GL_NV_vertex_program4"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBI2IEXTPROC_HPP)(GLuint index,GLint x,GLint y);

static inline void VertexAttribI2iEXT(GLuint index,GLint x,GLint y)
{
	static PFNVERTEXATTRIBI2IEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2IEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2iEXT","GL_NV_vertex_program4"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBI3IEXTPROC_HPP)(GLuint index,GLint x,GLint y,GLint z);

static inline void VertexAttribI3iEXT(GLuint index,GLint x,GLint y,GLint z)
{
	static PFNVERTEXATTRIBI3IEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3IEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3iEXT","GL_NV_vertex_program4"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBI4IEXTPROC_HPP)(GLuint index,GLint x,GLint y,GLint z,GLint w);

static inline void VertexAttribI4iEXT(GLuint index,GLint x,GLint y,GLint z,GLint w)
{
	static PFNVERTEXATTRIBI4IEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4IEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4iEXT","GL_NV_vertex_program4"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBI1UIEXTPROC_HPP)(GLuint index,GLuint x);

static inline void VertexAttribI1uiEXT(GLuint index,GLuint x)
{
	static PFNVERTEXATTRIBI1UIEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1UIEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1uiEXT","GL_NV_vertex_program4"));
	 fn(index,x);
}

typedef void (*PFNVERTEXATTRIBI2UIEXTPROC_HPP)(GLuint index,GLuint x,GLuint y);

static inline void VertexAttribI2uiEXT(GLuint index,GLuint x,GLuint y)
{
	static PFNVERTEXATTRIBI2UIEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2UIEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2uiEXT","GL_NV_vertex_program4"));
	 fn(index,x,y);
}

typedef void (*PFNVERTEXATTRIBI3UIEXTPROC_HPP)(GLuint index,GLuint x,GLuint y,GLuint z);

static inline void VertexAttribI3uiEXT(GLuint index,GLuint x,GLuint y,GLuint z)
{
	static PFNVERTEXATTRIBI3UIEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3UIEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3uiEXT","GL_NV_vertex_program4"));
	 fn(index,x,y,z);
}

typedef void (*PFNVERTEXATTRIBI4UIEXTPROC_HPP)(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w);

static inline void VertexAttribI4uiEXT(GLuint index,GLuint x,GLuint y,GLuint z,GLuint w)
{
	static PFNVERTEXATTRIBI4UIEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UIEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4uiEXT","GL_NV_vertex_program4"));
	 fn(index,x,y,z,w);
}

typedef void (*PFNVERTEXATTRIBI1IVEXTPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI1ivEXT(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI1IVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1IVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1ivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI2IVEXTPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI2ivEXT(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI2IVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2IVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2ivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI3IVEXTPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI3ivEXT(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI3IVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3IVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3ivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4IVEXTPROC_HPP)(GLuint index,const GLint *v);

static inline void VertexAttribI4ivEXT(GLuint index,const GLint *v)
{
	static PFNVERTEXATTRIBI4IVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4IVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4ivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI1UIVEXTPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI1uivEXT(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI1UIVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI1UIVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI1uivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI2UIVEXTPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI2uivEXT(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI2UIVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI2UIVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI2uivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI3UIVEXTPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI3uivEXT(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI3UIVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI3UIVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI3uivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4UIVEXTPROC_HPP)(GLuint index,const GLuint *v);

static inline void VertexAttribI4uivEXT(GLuint index,const GLuint *v)
{
	static PFNVERTEXATTRIBI4UIVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UIVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4uivEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4BVEXTPROC_HPP)(GLuint index,const GLbyte *v);

static inline void VertexAttribI4bvEXT(GLuint index,const GLbyte *v)
{
	static PFNVERTEXATTRIBI4BVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4BVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4bvEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4SVEXTPROC_HPP)(GLuint index,const GLshort *v);

static inline void VertexAttribI4svEXT(GLuint index,const GLshort *v)
{
	static PFNVERTEXATTRIBI4SVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4SVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4svEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4UBVEXTPROC_HPP)(GLuint index,const GLubyte *v);

static inline void VertexAttribI4ubvEXT(GLuint index,const GLubyte *v)
{
	static PFNVERTEXATTRIBI4UBVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4UBVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4ubvEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBI4USVEXTPROC_HPP)(GLuint index,const GLushort *v);

static inline void VertexAttribI4usvEXT(GLuint index,const GLushort *v)
{
	static PFNVERTEXATTRIBI4USVEXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBI4USVEXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribI4usvEXT","GL_NV_vertex_program4"));
	 fn(index,v);
}

typedef void (*PFNVERTEXATTRIBIPOINTEREXTPROC_HPP)(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer);

static inline void VertexAttribIPointerEXT(GLuint index,GLint size,GLenum type,GLsizei stride,const GLvoid *pointer)
{
	static PFNVERTEXATTRIBIPOINTEREXTPROC_HPP fn=reinterpret_cast<PFNVERTEXATTRIBIPOINTEREXTPROC_HPP>(_impl::_get_proc_address("glVertexAttribIPointerEXT","GL_NV_vertex_program4"));
	 fn(index,size,type,stride,pointer);
}

typedef void (*PFNGETVERTEXATTRIBIIVEXTPROC_HPP)(GLuint index,GLenum pname,GLint *params);

static inline void GetVertexAttribIivEXT(GLuint index,GLenum pname,GLint *params)
{
	static PFNGETVERTEXATTRIBIIVEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIIVEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribIivEXT","GL_NV_vertex_program4"));
	 fn(index,pname,params);
}

typedef void (*PFNGETVERTEXATTRIBIUIVEXTPROC_HPP)(GLuint index,GLenum pname,GLuint *params);

static inline void GetVertexAttribIuivEXT(GLuint index,GLenum pname,GLuint *params)
{
	static PFNGETVERTEXATTRIBIUIVEXTPROC_HPP fn=reinterpret_cast<PFNGETVERTEXATTRIBIUIVEXTPROC_HPP>(_impl::_get_proc_address("glGetVertexAttribIuivEXT","GL_NV_vertex_program4"));
	 fn(index,pname,params);
}
#ifndef GL_NV_video_capture

#define GL_NV_video_capture
#ifndef GL_VIDEO_BUFFER_NV
#define GL_VIDEO_BUFFER_NV                                              0x9020
#endif //GL_VIDEO_BUFFER_NV
#ifndef GL_VIDEO_BUFFER_BINDING_NV
#define GL_VIDEO_BUFFER_BINDING_NV                                      0x9021
#endif //GL_VIDEO_BUFFER_BINDING_NV
#ifndef GL_FIELD_UPPER_NV
#define GL_FIELD_UPPER_NV                                               0x9022
#endif //GL_FIELD_UPPER_NV
#ifndef GL_FIELD_LOWER_NV
#define GL_FIELD_LOWER_NV                                               0x9023
#endif //GL_FIELD_LOWER_NV
#ifndef GL_NUM_VIDEO_CAPTURE_STREAMS_NV
#define GL_NUM_VIDEO_CAPTURE_STREAMS_NV                                 0x9024
#endif //GL_NUM_VIDEO_CAPTURE_STREAMS_NV
#ifndef GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV
#define GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV                          0x9025
#endif //GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV
#ifndef GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV
#define GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV                            0x9026
#endif //GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV
#ifndef GL_LAST_VIDEO_CAPTURE_STATUS_NV
#define GL_LAST_VIDEO_CAPTURE_STATUS_NV                                 0x9027
#endif //GL_LAST_VIDEO_CAPTURE_STATUS_NV
#ifndef GL_VIDEO_BUFFER_PITCH_NV
#define GL_VIDEO_BUFFER_PITCH_NV                                        0x9028
#endif //GL_VIDEO_BUFFER_PITCH_NV
#ifndef GL_VIDEO_COLOR_CONVERSION_MATRIX_NV
#define GL_VIDEO_COLOR_CONVERSION_MATRIX_NV                             0x9029
#endif //GL_VIDEO_COLOR_CONVERSION_MATRIX_NV
#ifndef GL_VIDEO_COLOR_CONVERSION_MAX_NV
#define GL_VIDEO_COLOR_CONVERSION_MAX_NV                                0x902A
#endif //GL_VIDEO_COLOR_CONVERSION_MAX_NV
#ifndef GL_VIDEO_COLOR_CONVERSION_MIN_NV
#define GL_VIDEO_COLOR_CONVERSION_MIN_NV                                0x902B
#endif //GL_VIDEO_COLOR_CONVERSION_MIN_NV
#ifndef GL_VIDEO_COLOR_CONVERSION_OFFSET_NV
#define GL_VIDEO_COLOR_CONVERSION_OFFSET_NV                             0x902C
#endif //GL_VIDEO_COLOR_CONVERSION_OFFSET_NV
#ifndef GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV
#define GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV                              0x902D
#endif //GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV
#ifndef GL_PARTIAL_SUCCESS_NV
#define GL_PARTIAL_SUCCESS_NV                                           0x902E
#endif //GL_PARTIAL_SUCCESS_NV
#ifndef GL_SUCCESS_NV
#define GL_SUCCESS_NV                                                   0x902F
#endif //GL_SUCCESS_NV
#ifndef GL_FAILURE_NV
#define GL_FAILURE_NV                                                   0x9030
#endif //GL_FAILURE_NV
#ifndef GL_YCBYCR8_422_NV
#define GL_YCBYCR8_422_NV                                               0x9031
#endif //GL_YCBYCR8_422_NV
#ifndef GL_YCBAYCR8A_4224_NV
#define GL_YCBAYCR8A_4224_NV                                            0x9032
#endif //GL_YCBAYCR8A_4224_NV
#ifndef GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV
#define GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV                                0x9033
#endif //GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV
#ifndef GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV
#define GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV                     0x9034
#endif //GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV
#ifndef GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV
#define GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV                                0x9035
#endif //GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV
#ifndef GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV
#define GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV                     0x9036
#endif //GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV
#ifndef GL_Z4Y12Z4CB12Z4CR12_444_NV
#define GL_Z4Y12Z4CB12Z4CR12_444_NV                                     0x9037
#endif //GL_Z4Y12Z4CB12Z4CR12_444_NV
#ifndef GL_VIDEO_CAPTURE_FRAME_WIDTH_NV
#define GL_VIDEO_CAPTURE_FRAME_WIDTH_NV                                 0x9038
#endif //GL_VIDEO_CAPTURE_FRAME_WIDTH_NV
#ifndef GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV
#define GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV                                0x9039
#endif //GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV
#ifndef GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV
#define GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV                          0x903A
#endif //GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV
#ifndef GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV
#define GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV                          0x903B
#endif //GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV
#ifndef GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV
#define GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV                              0x903C
#endif //GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV

#endif //GL_NV_video_capture


typedef void (*PFNBEGINVIDEOCAPTURENVPROC_HPP)(GLuint video_capture_slot);

static inline void BeginVideoCaptureNV(GLuint video_capture_slot)
{
	static PFNBEGINVIDEOCAPTURENVPROC_HPP fn=reinterpret_cast<PFNBEGINVIDEOCAPTURENVPROC_HPP>(_impl::_get_proc_address("glBeginVideoCaptureNV","GL_NV_video_capture"));
	 fn(video_capture_slot);
}

typedef void (*PFNBINDVIDEOCAPTURESTREAMBUFFERNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLintptrARB offset);

static inline void BindVideoCaptureStreamBufferNV(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLintptrARB offset)
{
	static PFNBINDVIDEOCAPTURESTREAMBUFFERNVPROC_HPP fn=reinterpret_cast<PFNBINDVIDEOCAPTURESTREAMBUFFERNVPROC_HPP>(_impl::_get_proc_address("glBindVideoCaptureStreamBufferNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,frame_region,offset);
}

typedef void (*PFNBINDVIDEOCAPTURESTREAMTEXTURENVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLenum target,GLuint texture);

static inline void BindVideoCaptureStreamTextureNV(GLuint video_capture_slot,GLuint stream,GLenum frame_region,GLenum target,GLuint texture)
{
	static PFNBINDVIDEOCAPTURESTREAMTEXTURENVPROC_HPP fn=reinterpret_cast<PFNBINDVIDEOCAPTURESTREAMTEXTURENVPROC_HPP>(_impl::_get_proc_address("glBindVideoCaptureStreamTextureNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,frame_region,target,texture);
}

typedef void (*PFNENDVIDEOCAPTURENVPROC_HPP)(GLuint video_capture_slot);

static inline void EndVideoCaptureNV(GLuint video_capture_slot)
{
	static PFNENDVIDEOCAPTURENVPROC_HPP fn=reinterpret_cast<PFNENDVIDEOCAPTURENVPROC_HPP>(_impl::_get_proc_address("glEndVideoCaptureNV","GL_NV_video_capture"));
	 fn(video_capture_slot);
}

typedef void (*PFNGETVIDEOCAPTUREIVNVPROC_HPP)(GLuint video_capture_slot,GLenum pname,GLint *params);

static inline void GetVideoCaptureivNV(GLuint video_capture_slot,GLenum pname,GLint *params)
{
	static PFNGETVIDEOCAPTUREIVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOCAPTUREIVNVPROC_HPP>(_impl::_get_proc_address("glGetVideoCaptureivNV","GL_NV_video_capture"));
	 fn(video_capture_slot,pname,params);
}

typedef void (*PFNGETVIDEOCAPTURESTREAMIVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,GLint *params);

static inline void GetVideoCaptureStreamivNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLint *params)
{
	static PFNGETVIDEOCAPTURESTREAMIVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOCAPTURESTREAMIVNVPROC_HPP>(_impl::_get_proc_address("glGetVideoCaptureStreamivNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}

typedef void (*PFNGETVIDEOCAPTURESTREAMFVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,GLfloat *params);

static inline void GetVideoCaptureStreamfvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLfloat *params)
{
	static PFNGETVIDEOCAPTURESTREAMFVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOCAPTURESTREAMFVNVPROC_HPP>(_impl::_get_proc_address("glGetVideoCaptureStreamfvNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}

typedef void (*PFNGETVIDEOCAPTURESTREAMDVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,GLdouble *params);

static inline void GetVideoCaptureStreamdvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,GLdouble *params)
{
	static PFNGETVIDEOCAPTURESTREAMDVNVPROC_HPP fn=reinterpret_cast<PFNGETVIDEOCAPTURESTREAMDVNVPROC_HPP>(_impl::_get_proc_address("glGetVideoCaptureStreamdvNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}

typedef GLenum (*PFNVIDEOCAPTURENVPROC_HPP)(GLuint video_capture_slot,GLuint *sequence_num,GLuint64EXT *capture_time);

static inline GLenum VideoCaptureNV(GLuint video_capture_slot,GLuint *sequence_num,GLuint64EXT *capture_time)
{
	static PFNVIDEOCAPTURENVPROC_HPP fn=reinterpret_cast<PFNVIDEOCAPTURENVPROC_HPP>(_impl::_get_proc_address("glVideoCaptureNV","GL_NV_video_capture"));
	return fn(video_capture_slot,sequence_num,capture_time);
}

typedef void (*PFNVIDEOCAPTURESTREAMPARAMETERIVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLint *params);

static inline void VideoCaptureStreamParameterivNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLint *params)
{
	static PFNVIDEOCAPTURESTREAMPARAMETERIVNVPROC_HPP fn=reinterpret_cast<PFNVIDEOCAPTURESTREAMPARAMETERIVNVPROC_HPP>(_impl::_get_proc_address("glVideoCaptureStreamParameterivNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}

typedef void (*PFNVIDEOCAPTURESTREAMPARAMETERFVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLfloat *params);

static inline void VideoCaptureStreamParameterfvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLfloat *params)
{
	static PFNVIDEOCAPTURESTREAMPARAMETERFVNVPROC_HPP fn=reinterpret_cast<PFNVIDEOCAPTURESTREAMPARAMETERFVNVPROC_HPP>(_impl::_get_proc_address("glVideoCaptureStreamParameterfvNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}

typedef void (*PFNVIDEOCAPTURESTREAMPARAMETERDVNVPROC_HPP)(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLdouble *params);

static inline void VideoCaptureStreamParameterdvNV(GLuint video_capture_slot,GLuint stream,GLenum pname,const GLdouble *params)
{
	static PFNVIDEOCAPTURESTREAMPARAMETERDVNVPROC_HPP fn=reinterpret_cast<PFNVIDEOCAPTURESTREAMPARAMETERDVNVPROC_HPP>(_impl::_get_proc_address("glVideoCaptureStreamParameterdvNV","GL_NV_video_capture"));
	 fn(video_capture_slot,stream,pname,params);
}
#ifndef GL_NormalPointerType

#define GL_NormalPointerType

#endif //GL_NormalPointerType

#ifndef GL_OES_EGL_image_external

#define GL_OES_EGL_image_external
#ifndef GL_TEXTURE_EXTERNAL_OES
#define GL_TEXTURE_EXTERNAL_OES                                         0x8D65
#endif //GL_TEXTURE_EXTERNAL_OES
#ifndef GL_SAMPLER_EXTERNAL_OES
#define GL_SAMPLER_EXTERNAL_OES                                         0x8D66
#endif //GL_SAMPLER_EXTERNAL_OES
#ifndef GL_TEXTURE_BINDING_EXTERNAL_OES
#define GL_TEXTURE_BINDING_EXTERNAL_OES                                 0x8D67
#endif //GL_TEXTURE_BINDING_EXTERNAL_OES
#ifndef GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES
#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES                             0x8D68
#endif //GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES

#endif //GL_OES_EGL_image_external

#ifndef GL_OES_blend_equation_separate

#define GL_OES_blend_equation_separate
#ifndef GL_BLEND_EQUATION_RGB_OES
#define GL_BLEND_EQUATION_RGB_OES                                       0x8009
#endif //GL_BLEND_EQUATION_RGB_OES
#ifndef GL_BLEND_EQUATION_ALPHA_OES
#define GL_BLEND_EQUATION_ALPHA_OES                                     0x883D
#endif //GL_BLEND_EQUATION_ALPHA_OES

#endif //GL_OES_blend_equation_separate

#ifndef GL_OES_blend_func_separate

#define GL_OES_blend_func_separate
#ifndef GL_BLEND_DST_RGB_OES
#define GL_BLEND_DST_RGB_OES                                            0x80C8
#endif //GL_BLEND_DST_RGB_OES
#ifndef GL_BLEND_SRC_RGB_OES
#define GL_BLEND_SRC_RGB_OES                                            0x80C9
#endif //GL_BLEND_SRC_RGB_OES
#ifndef GL_BLEND_DST_ALPHA_OES
#define GL_BLEND_DST_ALPHA_OES                                          0x80CA
#endif //GL_BLEND_DST_ALPHA_OES
#ifndef GL_BLEND_SRC_ALPHA_OES
#define GL_BLEND_SRC_ALPHA_OES                                          0x80CB
#endif //GL_BLEND_SRC_ALPHA_OES

#endif //GL_OES_blend_func_separate

#ifndef GL_OES_blend_subtract

#define GL_OES_blend_subtract
#ifndef GL_FUNC_ADD_OES
#define GL_FUNC_ADD_OES                                                 0x8006
#endif //GL_FUNC_ADD_OES
#ifndef GL_BLEND_EQUATION_OES
#define GL_BLEND_EQUATION_OES                                           0x8009
#endif //GL_BLEND_EQUATION_OES
#ifndef GL_FUNC_SUBTRACT_OES
#define GL_FUNC_SUBTRACT_OES                                            0x800A
#endif //GL_FUNC_SUBTRACT_OES
#ifndef GL_FUNC_REVERSE_SUBTRACT_OES
#define GL_FUNC_REVERSE_SUBTRACT_OES                                    0x800B
#endif //GL_FUNC_REVERSE_SUBTRACT_OES

#endif //GL_OES_blend_subtract

#ifndef GL_OES_compressed_ETC1_RGB8_texture

#define GL_OES_compressed_ETC1_RGB8_texture
#ifndef GL_ETC1_RGB8_OES
#define GL_ETC1_RGB8_OES                                                0x8D64
#endif //GL_ETC1_RGB8_OES

#endif //GL_OES_compressed_ETC1_RGB8_texture

#ifndef GL_OES_compressed_paletted_texture

#define GL_OES_compressed_paletted_texture
#ifndef GL_PALETTE4_RGB8_OES
#define GL_PALETTE4_RGB8_OES                                            0x8B90
#endif //GL_PALETTE4_RGB8_OES
#ifndef GL_PALETTE4_RGBA8_OES
#define GL_PALETTE4_RGBA8_OES                                           0x8B91
#endif //GL_PALETTE4_RGBA8_OES
#ifndef GL_PALETTE4_R5_G6_B5_OES
#define GL_PALETTE4_R5_G6_B5_OES                                        0x8B92
#endif //GL_PALETTE4_R5_G6_B5_OES
#ifndef GL_PALETTE4_RGBA4_OES
#define GL_PALETTE4_RGBA4_OES                                           0x8B93
#endif //GL_PALETTE4_RGBA4_OES
#ifndef GL_PALETTE4_RGB5_A1_OES
#define GL_PALETTE4_RGB5_A1_OES                                         0x8B94
#endif //GL_PALETTE4_RGB5_A1_OES
#ifndef GL_PALETTE8_RGB8_OES
#define GL_PALETTE8_RGB8_OES                                            0x8B95
#endif //GL_PALETTE8_RGB8_OES
#ifndef GL_PALETTE8_RGBA8_OES
#define GL_PALETTE8_RGBA8_OES                                           0x8B96
#endif //GL_PALETTE8_RGBA8_OES
#ifndef GL_PALETTE8_R5_G6_B5_OES
#define GL_PALETTE8_R5_G6_B5_OES                                        0x8B97
#endif //GL_PALETTE8_R5_G6_B5_OES
#ifndef GL_PALETTE8_RGBA4_OES
#define GL_PALETTE8_RGBA4_OES                                           0x8B98
#endif //GL_PALETTE8_RGBA4_OES
#ifndef GL_PALETTE8_RGB5_A1_OES
#define GL_PALETTE8_RGB5_A1_OES                                         0x8B99
#endif //GL_PALETTE8_RGB5_A1_OES

#endif //GL_OES_compressed_paletted_texture

#ifndef GL_OES_depth24

#define GL_OES_depth24
#ifndef GL_DEPTH_COMPONENT24_OES
#define GL_DEPTH_COMPONENT24_OES                                        0x81A6
#endif //GL_DEPTH_COMPONENT24_OES

#endif //GL_OES_depth24

#ifndef GL_OES_depth32

#define GL_OES_depth32
#ifndef GL_DEPTH_COMPONENT32_OES
#define GL_DEPTH_COMPONENT32_OES                                        0x81A7
#endif //GL_DEPTH_COMPONENT32_OES

#endif //GL_OES_depth32

#ifndef GL_OES_draw_texture

#define GL_OES_draw_texture
#ifndef GL_TEXTURE_CROP_RECT_OES
#define GL_TEXTURE_CROP_RECT_OES                                        0x8B9D
#endif //GL_TEXTURE_CROP_RECT_OES

#endif //GL_OES_draw_texture

#ifndef GL_OES_fixed_point

#define GL_OES_fixed_point
#ifndef GL_FIXED_OES
#define GL_FIXED_OES                                                    0x140C
#endif //GL_FIXED_OES

#endif //GL_OES_fixed_point

#ifndef GL_OES_framebuffer_object

#define GL_OES_framebuffer_object
#ifndef GL_INVALID_FRAMEBUFFER_OPERATION_OES
#define GL_INVALID_FRAMEBUFFER_OPERATION_OES                            0x0506
#endif //GL_INVALID_FRAMEBUFFER_OPERATION_OES
#ifndef GL_RGBA4_OES
#define GL_RGBA4_OES                                                    0x8056
#endif //GL_RGBA4_OES
#ifndef GL_RGB5_A1_OES
#define GL_RGB5_A1_OES                                                  0x8057
#endif //GL_RGB5_A1_OES
#ifndef GL_DEPTH_COMPONENT16_OES
#define GL_DEPTH_COMPONENT16_OES                                        0x81A5
#endif //GL_DEPTH_COMPONENT16_OES
#ifndef GL_MAX_RENDERBUFFER_SIZE_OES
#define GL_MAX_RENDERBUFFER_SIZE_OES                                    0x84E8
#endif //GL_MAX_RENDERBUFFER_SIZE_OES
#ifndef GL_FRAMEBUFFER_BINDING_OES
#define GL_FRAMEBUFFER_BINDING_OES                                      0x8CA6
#endif //GL_FRAMEBUFFER_BINDING_OES
#ifndef GL_RENDERBUFFER_BINDING_OES
#define GL_RENDERBUFFER_BINDING_OES                                     0x8CA7
#endif //GL_RENDERBUFFER_BINDING_OES
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES                       0x8CD0
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES
#ifndef GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES                       0x8CD1
#endif //GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES                     0x8CD2
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES             0x8CD3
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES
#ifndef GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES                0x8CD4
#endif //GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES
#ifndef GL_FRAMEBUFFER_COMPLETE_OES
#define GL_FRAMEBUFFER_COMPLETE_OES                                     0x8CD5
#endif //GL_FRAMEBUFFER_COMPLETE_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES
#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES                        0x8CD6
#endif //GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES
#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES                0x8CD7
#endif //GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES
#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES                        0x8CD9
#endif //GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES
#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES                           0x8CDA
#endif //GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES
#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES                       0x8CDB
#endif //GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES
#ifndef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES
#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES                       0x8CDC
#endif //GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES
#ifndef GL_FRAMEBUFFER_UNSUPPORTED_OES
#define GL_FRAMEBUFFER_UNSUPPORTED_OES                                  0x8CDD
#endif //GL_FRAMEBUFFER_UNSUPPORTED_OES
#ifndef GL_COLOR_ATTACHMENT0_OES
#define GL_COLOR_ATTACHMENT0_OES                                        0x8CE0
#endif //GL_COLOR_ATTACHMENT0_OES
#ifndef GL_DEPTH_ATTACHMENT_OES
#define GL_DEPTH_ATTACHMENT_OES                                         0x8D00
#endif //GL_DEPTH_ATTACHMENT_OES
#ifndef GL_STENCIL_ATTACHMENT_OES
#define GL_STENCIL_ATTACHMENT_OES                                       0x8D20
#endif //GL_STENCIL_ATTACHMENT_OES
#ifndef GL_FRAMEBUFFER_OES
#define GL_FRAMEBUFFER_OES                                              0x8D40
#endif //GL_FRAMEBUFFER_OES
#ifndef GL_RENDERBUFFER_OES
#define GL_RENDERBUFFER_OES                                             0x8D41
#endif //GL_RENDERBUFFER_OES
#ifndef GL_RENDERBUFFER_WIDTH_OES
#define GL_RENDERBUFFER_WIDTH_OES                                       0x8D42
#endif //GL_RENDERBUFFER_WIDTH_OES
#ifndef GL_RENDERBUFFER_HEIGHT_OES
#define GL_RENDERBUFFER_HEIGHT_OES                                      0x8D43
#endif //GL_RENDERBUFFER_HEIGHT_OES
#ifndef GL_RENDERBUFFER_INTERNAL_FORMAT_OES
#define GL_RENDERBUFFER_INTERNAL_FORMAT_OES                             0x8D44
#endif //GL_RENDERBUFFER_INTERNAL_FORMAT_OES
#ifndef GL_STENCIL_INDEX1_OES
#define GL_STENCIL_INDEX1_OES                                           0x8D46
#endif //GL_STENCIL_INDEX1_OES
#ifndef GL_STENCIL_INDEX4_OES
#define GL_STENCIL_INDEX4_OES                                           0x8D47
#endif //GL_STENCIL_INDEX4_OES
#ifndef GL_STENCIL_INDEX8_OES
#define GL_STENCIL_INDEX8_OES                                           0x8D48
#endif //GL_STENCIL_INDEX8_OES
#ifndef GL_RENDERBUFFER_RED_SIZE_OES
#define GL_RENDERBUFFER_RED_SIZE_OES                                    0x8D50
#endif //GL_RENDERBUFFER_RED_SIZE_OES
#ifndef GL_RENDERBUFFER_GREEN_SIZE_OES
#define GL_RENDERBUFFER_GREEN_SIZE_OES                                  0x8D51
#endif //GL_RENDERBUFFER_GREEN_SIZE_OES
#ifndef GL_RENDERBUFFER_BLUE_SIZE_OES
#define GL_RENDERBUFFER_BLUE_SIZE_OES                                   0x8D52
#endif //GL_RENDERBUFFER_BLUE_SIZE_OES
#ifndef GL_RENDERBUFFER_ALPHA_SIZE_OES
#define GL_RENDERBUFFER_ALPHA_SIZE_OES                                  0x8D53
#endif //GL_RENDERBUFFER_ALPHA_SIZE_OES
#ifndef GL_RENDERBUFFER_DEPTH_SIZE_OES
#define GL_RENDERBUFFER_DEPTH_SIZE_OES                                  0x8D54
#endif //GL_RENDERBUFFER_DEPTH_SIZE_OES
#ifndef GL_RENDERBUFFER_STENCIL_SIZE_OES
#define GL_RENDERBUFFER_STENCIL_SIZE_OES                                0x8D55
#endif //GL_RENDERBUFFER_STENCIL_SIZE_OES
#ifndef GL_RGB565_OES
#define GL_RGB565_OES                                                   0x8D62
#endif //GL_RGB565_OES

#endif //GL_OES_framebuffer_object

#ifndef GL_OES_get_program_binary

#define GL_OES_get_program_binary
#ifndef GL_PROGRAM_BINARY_LENGTH_OES
#define GL_PROGRAM_BINARY_LENGTH_OES                                    0x8741
#endif //GL_PROGRAM_BINARY_LENGTH_OES
#ifndef GL_NUM_PROGRAM_BINARY_FORMATS_OES
#define GL_NUM_PROGRAM_BINARY_FORMATS_OES                               0x87FE
#endif //GL_NUM_PROGRAM_BINARY_FORMATS_OES
#ifndef GL_PROGRAM_BINARY_FORMATS_OES
#define GL_PROGRAM_BINARY_FORMATS_OES                                   0x87FF
#endif //GL_PROGRAM_BINARY_FORMATS_OES

#endif //GL_OES_get_program_binary

#ifndef GL_OES_mapbuffer

#define GL_OES_mapbuffer
#ifndef GL_WRITE_ONLY_OES
#define GL_WRITE_ONLY_OES                                               0x88B9
#endif //GL_WRITE_ONLY_OES
#ifndef GL_BUFFER_ACCESS_OES
#define GL_BUFFER_ACCESS_OES                                            0x88BB
#endif //GL_BUFFER_ACCESS_OES
#ifndef GL_BUFFER_MAPPED_OES
#define GL_BUFFER_MAPPED_OES                                            0x88BC
#endif //GL_BUFFER_MAPPED_OES
#ifndef GL_BUFFER_MAP_POINTER_OES
#define GL_BUFFER_MAP_POINTER_OES                                       0x88BD
#endif //GL_BUFFER_MAP_POINTER_OES

#endif //GL_OES_mapbuffer

#ifndef GL_OES_matrix_get

#define GL_OES_matrix_get
#ifndef GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES
#define GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES                       0x898D
#endif //GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES
#ifndef GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES
#define GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES                      0x898E
#endif //GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES
#ifndef GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES
#define GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES                         0x898F
#endif //GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES

#endif //GL_OES_matrix_get

#ifndef GL_OES_matrix_palette

#define GL_OES_matrix_palette
#ifndef GL_MAX_VERTEX_UNITS_OES
#define GL_MAX_VERTEX_UNITS_OES                                         0x86A4
#endif //GL_MAX_VERTEX_UNITS_OES
#ifndef GL_WEIGHT_ARRAY_TYPE_OES
#define GL_WEIGHT_ARRAY_TYPE_OES                                        0x86A9
#endif //GL_WEIGHT_ARRAY_TYPE_OES
#ifndef GL_WEIGHT_ARRAY_STRIDE_OES
#define GL_WEIGHT_ARRAY_STRIDE_OES                                      0x86AA
#endif //GL_WEIGHT_ARRAY_STRIDE_OES
#ifndef GL_WEIGHT_ARRAY_SIZE_OES
#define GL_WEIGHT_ARRAY_SIZE_OES                                        0x86AB
#endif //GL_WEIGHT_ARRAY_SIZE_OES
#ifndef GL_WEIGHT_ARRAY_POINTER_OES
#define GL_WEIGHT_ARRAY_POINTER_OES                                     0x86AC
#endif //GL_WEIGHT_ARRAY_POINTER_OES
#ifndef GL_WEIGHT_ARRAY_OES
#define GL_WEIGHT_ARRAY_OES                                             0x86AD
#endif //GL_WEIGHT_ARRAY_OES
#ifndef GL_MATRIX_PALETTE_OES
#define GL_MATRIX_PALETTE_OES                                           0x8840
#endif //GL_MATRIX_PALETTE_OES
#ifndef GL_MAX_PALETTE_MATRICES_OES
#define GL_MAX_PALETTE_MATRICES_OES                                     0x8842
#endif //GL_MAX_PALETTE_MATRICES_OES
#ifndef GL_CURRENT_PALETTE_MATRIX_OES
#define GL_CURRENT_PALETTE_MATRIX_OES                                   0x8843
#endif //GL_CURRENT_PALETTE_MATRIX_OES
#ifndef GL_MATRIX_INDEX_ARRAY_OES
#define GL_MATRIX_INDEX_ARRAY_OES                                       0x8844
#endif //GL_MATRIX_INDEX_ARRAY_OES
#ifndef GL_MATRIX_INDEX_ARRAY_SIZE_OES
#define GL_MATRIX_INDEX_ARRAY_SIZE_OES                                  0x8846
#endif //GL_MATRIX_INDEX_ARRAY_SIZE_OES
#ifndef GL_MATRIX_INDEX_ARRAY_TYPE_OES
#define GL_MATRIX_INDEX_ARRAY_TYPE_OES                                  0x8847
#endif //GL_MATRIX_INDEX_ARRAY_TYPE_OES
#ifndef GL_MATRIX_INDEX_ARRAY_STRIDE_OES
#define GL_MATRIX_INDEX_ARRAY_STRIDE_OES                                0x8848
#endif //GL_MATRIX_INDEX_ARRAY_STRIDE_OES
#ifndef GL_MATRIX_INDEX_ARRAY_POINTER_OES
#define GL_MATRIX_INDEX_ARRAY_POINTER_OES                               0x8849
#endif //GL_MATRIX_INDEX_ARRAY_POINTER_OES
#ifndef GL_WEIGHT_ARRAY_BUFFER_BINDING_OES
#define GL_WEIGHT_ARRAY_BUFFER_BINDING_OES                              0x889E
#endif //GL_WEIGHT_ARRAY_BUFFER_BINDING_OES
#ifndef GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES
#define GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES                        0x8B9E
#endif //GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES

#endif //GL_OES_matrix_palette

#ifndef GL_OES_packed_depth_stencil

#define GL_OES_packed_depth_stencil
#ifndef GL_DEPTH_STENCIL_OES
#define GL_DEPTH_STENCIL_OES                                            0x84F9
#endif //GL_DEPTH_STENCIL_OES
#ifndef GL_UNSIGNED_INT_24_8_OES
#define GL_UNSIGNED_INT_24_8_OES                                        0x84FA
#endif //GL_UNSIGNED_INT_24_8_OES
#ifndef GL_DEPTH24_STENCIL8_OES
#define GL_DEPTH24_STENCIL8_OES                                         0x88F0
#endif //GL_DEPTH24_STENCIL8_OES

#endif //GL_OES_packed_depth_stencil

#ifndef GL_OES_point_size_array

#define GL_OES_point_size_array
#ifndef GL_POINT_SIZE_ARRAY_TYPE_OES
#define GL_POINT_SIZE_ARRAY_TYPE_OES                                    0x898A
#endif //GL_POINT_SIZE_ARRAY_TYPE_OES
#ifndef GL_POINT_SIZE_ARRAY_STRIDE_OES
#define GL_POINT_SIZE_ARRAY_STRIDE_OES                                  0x898B
#endif //GL_POINT_SIZE_ARRAY_STRIDE_OES
#ifndef GL_POINT_SIZE_ARRAY_POINTER_OES
#define GL_POINT_SIZE_ARRAY_POINTER_OES                                 0x898C
#endif //GL_POINT_SIZE_ARRAY_POINTER_OES
#ifndef GL_POINT_SIZE_ARRAY_OES
#define GL_POINT_SIZE_ARRAY_OES                                         0x8B9C
#endif //GL_POINT_SIZE_ARRAY_OES
#ifndef GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES
#define GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES                          0x8B9F
#endif //GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES

#endif //GL_OES_point_size_array

#ifndef GL_OES_point_sprite

#define GL_OES_point_sprite

#endif //GL_OES_point_sprite

#ifndef GL_OES_read_format

#define GL_OES_read_format
#ifndef GL_IMPLEMENTATION_COLOR_READ_TYPE_OES
#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES                           0x8B9A
#endif //GL_IMPLEMENTATION_COLOR_READ_TYPE_OES
#ifndef GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES
#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES                         0x8B9B
#endif //GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES

#endif //GL_OES_read_format

#ifndef GL_OES_rgb8_rgba8

#define GL_OES_rgb8_rgba8
#ifndef GL_RGB8
#define GL_RGB8                                                         0x8051
#endif //GL_RGB8
#ifndef GL_RGBA8
#define GL_RGBA8                                                        0x8058
#endif //GL_RGBA8

#endif //GL_OES_rgb8_rgba8

#ifndef GL_OES_standard_derivatives

#define GL_OES_standard_derivatives
#ifndef GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES                          0x8B8B
#endif //GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES

#endif //GL_OES_standard_derivatives

#ifndef GL_OES_stencil1

#define GL_OES_stencil1

#endif //GL_OES_stencil1

#ifndef GL_OES_stencil4

#define GL_OES_stencil4

#endif //GL_OES_stencil4

#ifndef GL_OES_stencil8

#define GL_OES_stencil8

#endif //GL_OES_stencil8

#ifndef GL_OES_stencil_wrap

#define GL_OES_stencil_wrap
#ifndef GL_INCR_WRAP_OES
#define GL_INCR_WRAP_OES                                                0x8507
#endif //GL_INCR_WRAP_OES
#ifndef GL_DECR_WRAP_OES
#define GL_DECR_WRAP_OES                                                0x8508
#endif //GL_DECR_WRAP_OES

#endif //GL_OES_stencil_wrap

#ifndef GL_OES_surfaceless_context

#define GL_OES_surfaceless_context
#ifndef GL_FRAMEBUFFER_UNDEFINED_OES
#define GL_FRAMEBUFFER_UNDEFINED_OES                                    0x8219
#endif //GL_FRAMEBUFFER_UNDEFINED_OES

#endif //GL_OES_surfaceless_context

#ifndef GL_OES_texture3D

#define GL_OES_texture3D
#ifndef GL_TEXTURE_3D_BINDING_OES
#define GL_TEXTURE_3D_BINDING_OES                                       0x806A
#endif //GL_TEXTURE_3D_BINDING_OES
#ifndef GL_TEXTURE_3D_OES
#define GL_TEXTURE_3D_OES                                               0x806F
#endif //GL_TEXTURE_3D_OES
#ifndef GL_TEXTURE_WRAP_R_OES
#define GL_TEXTURE_WRAP_R_OES                                           0x8072
#endif //GL_TEXTURE_WRAP_R_OES
#ifndef GL_MAX_3D_TEXTURE_SIZE_OES
#define GL_MAX_3D_TEXTURE_SIZE_OES                                      0x8073
#endif //GL_MAX_3D_TEXTURE_SIZE_OES
#ifndef GL_SAMPLER_3D_OES
#define GL_SAMPLER_3D_OES                                               0x8B5F
#endif //GL_SAMPLER_3D_OES

#endif //GL_OES_texture3D

#ifndef GL_OES_texture_cube_map

#define GL_OES_texture_cube_map
#ifndef GL_TEXTURE_GEN_MODE
#define GL_TEXTURE_GEN_MODE                                             0x2500
#endif //GL_TEXTURE_GEN_MODE
#ifndef GL_NORMAL_MAP_OES
#define GL_NORMAL_MAP_OES                                               0x8511
#endif //GL_NORMAL_MAP_OES
#ifndef GL_REFLECTION_MAP_OES
#define GL_REFLECTION_MAP_OES                                           0x8512
#endif //GL_REFLECTION_MAP_OES
#ifndef GL_TEXTURE_CUBE_MAP_OES
#define GL_TEXTURE_CUBE_MAP_OES                                         0x8513
#endif //GL_TEXTURE_CUBE_MAP_OES
#ifndef GL_TEXTURE_BINDING_CUBE_MAP_OES
#define GL_TEXTURE_BINDING_CUBE_MAP_OES                                 0x8514
#endif //GL_TEXTURE_BINDING_CUBE_MAP_OES
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES                              0x8515
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES                              0x8516
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES                              0x8517
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES                              0x8518
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES
#ifndef GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES                              0x8519
#endif //GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES
#ifndef GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES                              0x851A
#endif //GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES
#ifndef GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES
#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES                                0x851C
#endif //GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES
#ifndef GL_TEXTURE_GEN_STR_OES
#define GL_TEXTURE_GEN_STR_OES                                          0x8D60
#endif //GL_TEXTURE_GEN_STR_OES

#endif //GL_OES_texture_cube_map

#ifndef GL_OES_texture_env_crossbar

#define GL_OES_texture_env_crossbar

#endif //GL_OES_texture_env_crossbar

#ifndef GL_OES_texture_float

#define GL_OES_texture_float
#ifndef GL_HALF_FLOAT_OES
#define GL_HALF_FLOAT_OES                                               0x8D61
#endif //GL_HALF_FLOAT_OES

#endif //GL_OES_texture_float

#ifndef GL_OES_texture_mirrored_repeat

#define GL_OES_texture_mirrored_repeat
#ifndef GL_MIRRORED_REPEAT_OES
#define GL_MIRRORED_REPEAT_OES                                          0x8370
#endif //GL_MIRRORED_REPEAT_OES

#endif //GL_OES_texture_mirrored_repeat

#ifndef GL_OES_vertex_half_float

#define GL_OES_vertex_half_float

#endif //GL_OES_vertex_half_float

#ifndef GL_OES_vertex_type_10_10_10_2

#define GL_OES_vertex_type_10_10_10_2
#ifndef GL_UNSIGNED_INT_10_10_10_2_OES
#define GL_UNSIGNED_INT_10_10_10_2_OES                                  0x8DF6
#endif //GL_UNSIGNED_INT_10_10_10_2_OES
#ifndef GL_INT_10_10_10_2_OES
#define GL_INT_10_10_10_2_OES                                           0x8DF7
#endif //GL_INT_10_10_10_2_OES

#endif //GL_OES_vertex_type_10_10_10_2

#ifndef GL_OML_interlace

#define GL_OML_interlace
#ifndef GL_INTERLACE_OML
#define GL_INTERLACE_OML                                                0x8980
#endif //GL_INTERLACE_OML
#ifndef GL_INTERLACE_READ_OML
#define GL_INTERLACE_READ_OML                                           0x8981
#endif //GL_INTERLACE_READ_OML

#endif //GL_OML_interlace

#ifndef GL_OML_resample

#define GL_OML_resample
#ifndef GL_PACK_RESAMPLE_OML
#define GL_PACK_RESAMPLE_OML                                            0x8984
#endif //GL_PACK_RESAMPLE_OML
#ifndef GL_UNPACK_RESAMPLE_OML
#define GL_UNPACK_RESAMPLE_OML                                          0x8985
#endif //GL_UNPACK_RESAMPLE_OML
#ifndef GL_RESAMPLE_REPLICATE_OML
#define GL_RESAMPLE_REPLICATE_OML                                       0x8986
#endif //GL_RESAMPLE_REPLICATE_OML
#ifndef GL_RESAMPLE_ZERO_FILL_OML
#define GL_RESAMPLE_ZERO_FILL_OML                                       0x8987
#endif //GL_RESAMPLE_ZERO_FILL_OML
#ifndef GL_RESAMPLE_AVERAGE_OML
#define GL_RESAMPLE_AVERAGE_OML                                         0x8988
#endif //GL_RESAMPLE_AVERAGE_OML
#ifndef GL_RESAMPLE_DECIMATE_OML
#define GL_RESAMPLE_DECIMATE_OML                                        0x8989
#endif //GL_RESAMPLE_DECIMATE_OML

#endif //GL_OML_resample

#ifndef GL_OML_subsample

#define GL_OML_subsample
#ifndef GL_FORMAT_SUBSAMPLE_24_24_OML
#define GL_FORMAT_SUBSAMPLE_24_24_OML                                   0x8982
#endif //GL_FORMAT_SUBSAMPLE_24_24_OML
#ifndef GL_FORMAT_SUBSAMPLE_244_244_OML
#define GL_FORMAT_SUBSAMPLE_244_244_OML                                 0x8983
#endif //GL_FORMAT_SUBSAMPLE_244_244_OML

#endif //GL_OML_subsample

#ifndef GL_PGI_misc_hints

#define GL_PGI_misc_hints

#endif //GL_PGI_misc_hints


typedef void (*PFNHINTPGIPROC_HPP)(GLenum target,GLint mode);

static inline void HintPGI(GLenum target,GLint mode)
{
	static PFNHINTPGIPROC_HPP fn=reinterpret_cast<PFNHINTPGIPROC_HPP>(_impl::_get_proc_address("glHintPGI","GL_PGI_misc_hints"));
	 fn(target,mode);
}
#ifndef GL_PixelCopyType

#define GL_PixelCopyType
#ifndef GL_COLOR
#define GL_COLOR                                                        0x1800
#endif //GL_COLOR
#ifndef GL_DEPTH
#define GL_DEPTH                                                        0x1801
#endif //GL_DEPTH
#ifndef GL_STENCIL
#define GL_STENCIL                                                      0x1802
#endif //GL_STENCIL

#endif //GL_PixelCopyType

#ifndef GL_PixelFormat

#define GL_PixelFormat
#ifndef GL_COLOR_INDEX
#define GL_COLOR_INDEX                                                  0x1900
#endif //GL_COLOR_INDEX
#ifndef GL_STENCIL_INDEX
#define GL_STENCIL_INDEX                                                0x1901
#endif //GL_STENCIL_INDEX
#ifndef GL_DEPTH_COMPONENT
#define GL_DEPTH_COMPONENT                                              0x1902
#endif //GL_DEPTH_COMPONENT
#ifndef GL_RED
#define GL_RED                                                          0x1903
#endif //GL_RED
#ifndef GL_GREEN
#define GL_GREEN                                                        0x1904
#endif //GL_GREEN
#ifndef GL_BLUE
#define GL_BLUE                                                         0x1905
#endif //GL_BLUE
#ifndef GL_ALPHA
#define GL_ALPHA                                                        0x1906
#endif //GL_ALPHA
#ifndef GL_RGB
#define GL_RGB                                                          0x1907
#endif //GL_RGB
#ifndef GL_RGBA
#define GL_RGBA                                                         0x1908
#endif //GL_RGBA
#ifndef GL_LUMINANCE
#define GL_LUMINANCE                                                    0x1909
#endif //GL_LUMINANCE
#ifndef GL_LUMINANCE_ALPHA
#define GL_LUMINANCE_ALPHA                                              0x190A
#endif //GL_LUMINANCE_ALPHA
#ifndef GL_YCRCB_422_SGIX
#define GL_YCRCB_422_SGIX                                               0x81BB
#endif //GL_YCRCB_422_SGIX
#ifndef GL_YCRCB_444_SGIX
#define GL_YCRCB_444_SGIX                                               0x81BC
#endif //GL_YCRCB_444_SGIX

#endif //GL_PixelFormat

#ifndef GL_PixelInternalFormat

#define GL_PixelInternalFormat
#ifndef GL_R3_G3_B2
#define GL_R3_G3_B2                                                     0x2A10
#endif //GL_R3_G3_B2
#ifndef GL_ALPHA4
#define GL_ALPHA4                                                       0x803B
#endif //GL_ALPHA4
#ifndef GL_ALPHA8
#define GL_ALPHA8                                                       0x803C
#endif //GL_ALPHA8
#ifndef GL_ALPHA12
#define GL_ALPHA12                                                      0x803D
#endif //GL_ALPHA12
#ifndef GL_ALPHA16
#define GL_ALPHA16                                                      0x803E
#endif //GL_ALPHA16
#ifndef GL_LUMINANCE4
#define GL_LUMINANCE4                                                   0x803F
#endif //GL_LUMINANCE4
#ifndef GL_LUMINANCE8
#define GL_LUMINANCE8                                                   0x8040
#endif //GL_LUMINANCE8
#ifndef GL_LUMINANCE12
#define GL_LUMINANCE12                                                  0x8041
#endif //GL_LUMINANCE12
#ifndef GL_LUMINANCE16
#define GL_LUMINANCE16                                                  0x8042
#endif //GL_LUMINANCE16
#ifndef GL_LUMINANCE4_ALPHA4
#define GL_LUMINANCE4_ALPHA4                                            0x8043
#endif //GL_LUMINANCE4_ALPHA4
#ifndef GL_LUMINANCE6_ALPHA2
#define GL_LUMINANCE6_ALPHA2                                            0x8044
#endif //GL_LUMINANCE6_ALPHA2
#ifndef GL_LUMINANCE8_ALPHA8
#define GL_LUMINANCE8_ALPHA8                                            0x8045
#endif //GL_LUMINANCE8_ALPHA8
#ifndef GL_LUMINANCE12_ALPHA4
#define GL_LUMINANCE12_ALPHA4                                           0x8046
#endif //GL_LUMINANCE12_ALPHA4
#ifndef GL_LUMINANCE12_ALPHA12
#define GL_LUMINANCE12_ALPHA12                                          0x8047
#endif //GL_LUMINANCE12_ALPHA12
#ifndef GL_LUMINANCE16_ALPHA16
#define GL_LUMINANCE16_ALPHA16                                          0x8048
#endif //GL_LUMINANCE16_ALPHA16
#ifndef GL_INTENSITY
#define GL_INTENSITY                                                    0x8049
#endif //GL_INTENSITY
#ifndef GL_INTENSITY4
#define GL_INTENSITY4                                                   0x804A
#endif //GL_INTENSITY4
#ifndef GL_INTENSITY8
#define GL_INTENSITY8                                                   0x804B
#endif //GL_INTENSITY8
#ifndef GL_INTENSITY12
#define GL_INTENSITY12                                                  0x804C
#endif //GL_INTENSITY12
#ifndef GL_INTENSITY16
#define GL_INTENSITY16                                                  0x804D
#endif //GL_INTENSITY16
#ifndef GL_RGB4
#define GL_RGB4                                                         0x804F
#endif //GL_RGB4
#ifndef GL_RGB5
#define GL_RGB5                                                         0x8050
#endif //GL_RGB5
#ifndef GL_RGB10
#define GL_RGB10                                                        0x8052
#endif //GL_RGB10
#ifndef GL_RGB12
#define GL_RGB12                                                        0x8053
#endif //GL_RGB12
#ifndef GL_RGB16
#define GL_RGB16                                                        0x8054
#endif //GL_RGB16
#ifndef GL_RGBA2
#define GL_RGBA2                                                        0x8055
#endif //GL_RGBA2
#ifndef GL_RGBA4
#define GL_RGBA4                                                        0x8056
#endif //GL_RGBA4
#ifndef GL_RGB5_A1
#define GL_RGB5_A1                                                      0x8057
#endif //GL_RGB5_A1
#ifndef GL_RGB10_A2
#define GL_RGB10_A2                                                     0x8059
#endif //GL_RGB10_A2
#ifndef GL_RGBA12
#define GL_RGBA12                                                       0x805A
#endif //GL_RGBA12
#ifndef GL_RGBA16
#define GL_RGBA16                                                       0x805B
#endif //GL_RGBA16
#ifndef GL_DUAL_ALPHA4_SGIS
#define GL_DUAL_ALPHA4_SGIS                                             0x8110
#endif //GL_DUAL_ALPHA4_SGIS
#ifndef GL_DUAL_ALPHA8_SGIS
#define GL_DUAL_ALPHA8_SGIS                                             0x8111
#endif //GL_DUAL_ALPHA8_SGIS
#ifndef GL_DUAL_ALPHA12_SGIS
#define GL_DUAL_ALPHA12_SGIS                                            0x8112
#endif //GL_DUAL_ALPHA12_SGIS
#ifndef GL_DUAL_ALPHA16_SGIS
#define GL_DUAL_ALPHA16_SGIS                                            0x8113
#endif //GL_DUAL_ALPHA16_SGIS
#ifndef GL_DUAL_LUMINANCE4_SGIS
#define GL_DUAL_LUMINANCE4_SGIS                                         0x8114
#endif //GL_DUAL_LUMINANCE4_SGIS
#ifndef GL_DUAL_LUMINANCE8_SGIS
#define GL_DUAL_LUMINANCE8_SGIS                                         0x8115
#endif //GL_DUAL_LUMINANCE8_SGIS
#ifndef GL_DUAL_LUMINANCE12_SGIS
#define GL_DUAL_LUMINANCE12_SGIS                                        0x8116
#endif //GL_DUAL_LUMINANCE12_SGIS
#ifndef GL_DUAL_LUMINANCE16_SGIS
#define GL_DUAL_LUMINANCE16_SGIS                                        0x8117
#endif //GL_DUAL_LUMINANCE16_SGIS
#ifndef GL_DUAL_INTENSITY4_SGIS
#define GL_DUAL_INTENSITY4_SGIS                                         0x8118
#endif //GL_DUAL_INTENSITY4_SGIS
#ifndef GL_DUAL_INTENSITY8_SGIS
#define GL_DUAL_INTENSITY8_SGIS                                         0x8119
#endif //GL_DUAL_INTENSITY8_SGIS
#ifndef GL_DUAL_INTENSITY12_SGIS
#define GL_DUAL_INTENSITY12_SGIS                                        0x811A
#endif //GL_DUAL_INTENSITY12_SGIS
#ifndef GL_DUAL_INTENSITY16_SGIS
#define GL_DUAL_INTENSITY16_SGIS                                        0x811B
#endif //GL_DUAL_INTENSITY16_SGIS
#ifndef GL_DUAL_LUMINANCE_ALPHA4_SGIS
#define GL_DUAL_LUMINANCE_ALPHA4_SGIS                                   0x811C
#endif //GL_DUAL_LUMINANCE_ALPHA4_SGIS
#ifndef GL_DUAL_LUMINANCE_ALPHA8_SGIS
#define GL_DUAL_LUMINANCE_ALPHA8_SGIS                                   0x811D
#endif //GL_DUAL_LUMINANCE_ALPHA8_SGIS
#ifndef GL_QUAD_ALPHA4_SGIS
#define GL_QUAD_ALPHA4_SGIS                                             0x811E
#endif //GL_QUAD_ALPHA4_SGIS
#ifndef GL_QUAD_ALPHA8_SGIS
#define GL_QUAD_ALPHA8_SGIS                                             0x811F
#endif //GL_QUAD_ALPHA8_SGIS
#ifndef GL_QUAD_LUMINANCE4_SGIS
#define GL_QUAD_LUMINANCE4_SGIS                                         0x8120
#endif //GL_QUAD_LUMINANCE4_SGIS
#ifndef GL_QUAD_LUMINANCE8_SGIS
#define GL_QUAD_LUMINANCE8_SGIS                                         0x8121
#endif //GL_QUAD_LUMINANCE8_SGIS
#ifndef GL_QUAD_INTENSITY4_SGIS
#define GL_QUAD_INTENSITY4_SGIS                                         0x8122
#endif //GL_QUAD_INTENSITY4_SGIS
#ifndef GL_QUAD_INTENSITY8_SGIS
#define GL_QUAD_INTENSITY8_SGIS                                         0x8123
#endif //GL_QUAD_INTENSITY8_SGIS
#ifndef GL_DEPTH_COMPONENT16_SGIX
#define GL_DEPTH_COMPONENT16_SGIX                                       0x81A5
#endif //GL_DEPTH_COMPONENT16_SGIX
#ifndef GL_DEPTH_COMPONENT24_SGIX
#define GL_DEPTH_COMPONENT24_SGIX                                       0x81A6
#endif //GL_DEPTH_COMPONENT24_SGIX
#ifndef GL_DEPTH_COMPONENT32_SGIX
#define GL_DEPTH_COMPONENT32_SGIX                                       0x81A7
#endif //GL_DEPTH_COMPONENT32_SGIX

#endif //GL_PixelInternalFormat

#ifndef GL_PixelMap

#define GL_PixelMap

#endif //GL_PixelMap

#ifndef GL_PixelStoreParameter

#define GL_PixelStoreParameter

#endif //GL_PixelStoreParameter

#ifndef GL_PixelStoreResampleMode

#define GL_PixelStoreResampleMode
#ifndef GL_RESAMPLE_DECIMATE_SGIX
#define GL_RESAMPLE_DECIMATE_SGIX                                       0x8430
#endif //GL_RESAMPLE_DECIMATE_SGIX
#ifndef GL_RESAMPLE_REPLICATE_SGIX
#define GL_RESAMPLE_REPLICATE_SGIX                                      0x8433
#endif //GL_RESAMPLE_REPLICATE_SGIX
#ifndef GL_RESAMPLE_ZERO_FILL_SGIX
#define GL_RESAMPLE_ZERO_FILL_SGIX                                      0x8434
#endif //GL_RESAMPLE_ZERO_FILL_SGIX

#endif //GL_PixelStoreResampleMode

#ifndef GL_PixelStoreSubsampleRate

#define GL_PixelStoreSubsampleRate
#ifndef GL_PIXEL_SUBSAMPLE_4444_SGIX
#define GL_PIXEL_SUBSAMPLE_4444_SGIX                                    0x85A2
#endif //GL_PIXEL_SUBSAMPLE_4444_SGIX
#ifndef GL_PIXEL_SUBSAMPLE_2424_SGIX
#define GL_PIXEL_SUBSAMPLE_2424_SGIX                                    0x85A3
#endif //GL_PIXEL_SUBSAMPLE_2424_SGIX
#ifndef GL_PIXEL_SUBSAMPLE_4242_SGIX
#define GL_PIXEL_SUBSAMPLE_4242_SGIX                                    0x85A4
#endif //GL_PIXEL_SUBSAMPLE_4242_SGIX

#endif //GL_PixelStoreSubsampleRate

#ifndef GL_PixelTexGenMode

#define GL_PixelTexGenMode
#ifndef GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX
#define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX                             0x8187
#endif //GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX
#ifndef GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX
#define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX                          0x8188
#endif //GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX
#ifndef GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX
#define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX                                  0x8189
#endif //GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX
#ifndef GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX
#define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX                                  0x818A
#endif //GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX

#endif //GL_PixelTexGenMode

#ifndef GL_PixelTexGenParameterNameSGIS

#define GL_PixelTexGenParameterNameSGIS
#ifndef GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS
#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS                               0x8354
#endif //GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS
#ifndef GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS
#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS                             0x8355
#endif //GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS

#endif //GL_PixelTexGenParameterNameSGIS

#ifndef GL_PixelTransferParameter

#define GL_PixelTransferParameter

#endif //GL_PixelTransferParameter

#ifndef GL_PixelType

#define GL_PixelType
#ifndef GL_BITMAP
#define GL_BITMAP                                                       0x1A00
#endif //GL_BITMAP

#endif //GL_PixelType

#ifndef GL_PointParameterNameSGIS

#define GL_PointParameterNameSGIS

#endif //GL_PointParameterNameSGIS

#ifndef GL_PolygonMode

#define GL_PolygonMode

#endif //GL_PolygonMode

#ifndef GL_QCOM_alpha_test

#define GL_QCOM_alpha_test
#ifndef GL_ALPHA_TEST_QCOM
#define GL_ALPHA_TEST_QCOM                                              0x0BC0
#endif //GL_ALPHA_TEST_QCOM
#ifndef GL_ALPHA_TEST_FUNC_QCOM
#define GL_ALPHA_TEST_FUNC_QCOM                                         0x0BC1
#endif //GL_ALPHA_TEST_FUNC_QCOM
#ifndef GL_ALPHA_TEST_REF_QCOM
#define GL_ALPHA_TEST_REF_QCOM                                          0x0BC2
#endif //GL_ALPHA_TEST_REF_QCOM

#endif //GL_QCOM_alpha_test

#ifndef GL_QCOM_binning_control

#define GL_QCOM_binning_control
#ifndef GL_BINNING_CONTROL_HINT_QCOM
#define GL_BINNING_CONTROL_HINT_QCOM                                    0x8FB0
#endif //GL_BINNING_CONTROL_HINT_QCOM
#ifndef GL_CPU_OPTIMIZED_QCOM
#define GL_CPU_OPTIMIZED_QCOM                                           0x8FB1
#endif //GL_CPU_OPTIMIZED_QCOM
#ifndef GL_GPU_OPTIMIZED_QCOM
#define GL_GPU_OPTIMIZED_QCOM                                           0x8FB2
#endif //GL_GPU_OPTIMIZED_QCOM
#ifndef GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM
#define GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM                            0x8FB3
#endif //GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM

#endif //GL_QCOM_binning_control

#ifndef GL_QCOM_driver_control

#define GL_QCOM_driver_control
#ifndef GL_PERFMON_GLOBAL_MODE_QCOM
#define GL_PERFMON_GLOBAL_MODE_QCOM                                     0x8FA0
#endif //GL_PERFMON_GLOBAL_MODE_QCOM

#endif //GL_QCOM_driver_control

#ifndef GL_QCOM_extended_get

#define GL_QCOM_extended_get
#ifndef GL_TEXTURE_WIDTH_QCOM
#define GL_TEXTURE_WIDTH_QCOM                                           0x8BD2
#endif //GL_TEXTURE_WIDTH_QCOM
#ifndef GL_TEXTURE_HEIGHT_QCOM
#define GL_TEXTURE_HEIGHT_QCOM                                          0x8BD3
#endif //GL_TEXTURE_HEIGHT_QCOM
#ifndef GL_TEXTURE_DEPTH_QCOM
#define GL_TEXTURE_DEPTH_QCOM                                           0x8BD4
#endif //GL_TEXTURE_DEPTH_QCOM
#ifndef GL_TEXTURE_INTERNAL_FORMAT_QCOM
#define GL_TEXTURE_INTERNAL_FORMAT_QCOM                                 0x8BD5
#endif //GL_TEXTURE_INTERNAL_FORMAT_QCOM
#ifndef GL_TEXTURE_FORMAT_QCOM
#define GL_TEXTURE_FORMAT_QCOM                                          0x8BD6
#endif //GL_TEXTURE_FORMAT_QCOM
#ifndef GL_TEXTURE_TYPE_QCOM
#define GL_TEXTURE_TYPE_QCOM                                            0x8BD7
#endif //GL_TEXTURE_TYPE_QCOM
#ifndef GL_TEXTURE_IMAGE_VALID_QCOM
#define GL_TEXTURE_IMAGE_VALID_QCOM                                     0x8BD8
#endif //GL_TEXTURE_IMAGE_VALID_QCOM
#ifndef GL_TEXTURE_NUM_LEVELS_QCOM
#define GL_TEXTURE_NUM_LEVELS_QCOM                                      0x8BD9
#endif //GL_TEXTURE_NUM_LEVELS_QCOM
#ifndef GL_TEXTURE_TARGET_QCOM
#define GL_TEXTURE_TARGET_QCOM                                          0x8BDA
#endif //GL_TEXTURE_TARGET_QCOM
#ifndef GL_TEXTURE_OBJECT_VALID_QCOM
#define GL_TEXTURE_OBJECT_VALID_QCOM                                    0x8BDB
#endif //GL_TEXTURE_OBJECT_VALID_QCOM
#ifndef GL_STATE_RESTORE
#define GL_STATE_RESTORE                                                0x8BDC
#endif //GL_STATE_RESTORE

#endif //GL_QCOM_extended_get

#ifndef GL_QCOM_writeonly_rendering

#define GL_QCOM_writeonly_rendering
#ifndef GL_WRITEONLY_RENDERING_QCOM
#define GL_WRITEONLY_RENDERING_QCOM                                     0x8823
#endif //GL_WRITEONLY_RENDERING_QCOM

#endif //GL_QCOM_writeonly_rendering

#ifndef GL_REND_screen_coordinates

#define GL_REND_screen_coordinates
#ifndef GL_SCREEN_COORDINATES_REND
#define GL_SCREEN_COORDINATES_REND                                      0x8490
#endif //GL_SCREEN_COORDINATES_REND
#ifndef GL_INVERTED_SCREEN_W_REND
#define GL_INVERTED_SCREEN_W_REND                                       0x8491
#endif //GL_INVERTED_SCREEN_W_REND

#endif //GL_REND_screen_coordinates

#ifndef GL_ReadBufferMode

#define GL_ReadBufferMode

#endif //GL_ReadBufferMode

#ifndef GL_RenderingMode

#define GL_RenderingMode
#ifndef GL_RENDER
#define GL_RENDER                                                       0x1C00
#endif //GL_RENDER
#ifndef GL_FEEDBACK
#define GL_FEEDBACK                                                     0x1C01
#endif //GL_FEEDBACK
#ifndef GL_SELECT
#define GL_SELECT                                                       0x1C02
#endif //GL_SELECT

#endif //GL_RenderingMode

#ifndef GL_S3_s3tc

#define GL_S3_s3tc
#ifndef GL_RGB_S3TC
#define GL_RGB_S3TC                                                     0x83A0
#endif //GL_RGB_S3TC
#ifndef GL_RGB4_S3TC
#define GL_RGB4_S3TC                                                    0x83A1
#endif //GL_RGB4_S3TC
#ifndef GL_RGBA_S3TC
#define GL_RGBA_S3TC                                                    0x83A2
#endif //GL_RGBA_S3TC
#ifndef GL_RGBA4_S3TC
#define GL_RGBA4_S3TC                                                   0x83A3
#endif //GL_RGBA4_S3TC
#ifndef GL_RGBA_DXT5_S3TC
#define GL_RGBA_DXT5_S3TC                                               0x83A4
#endif //GL_RGBA_DXT5_S3TC
#ifndef GL_RGBA4_DXT5_S3TC
#define GL_RGBA4_DXT5_S3TC                                              0x83A5
#endif //GL_RGBA4_DXT5_S3TC

#endif //GL_S3_s3tc

#ifndef GL_SGIS_detail_texture

#define GL_SGIS_detail_texture
#ifndef GL_DETAIL_TEXTURE_2D_SGIS
#define GL_DETAIL_TEXTURE_2D_SGIS                                       0x8095
#endif //GL_DETAIL_TEXTURE_2D_SGIS
#ifndef GL_LINEAR_DETAIL_SGIS
#define GL_LINEAR_DETAIL_SGIS                                           0x8097
#endif //GL_LINEAR_DETAIL_SGIS
#ifndef GL_LINEAR_DETAIL_ALPHA_SGIS
#define GL_LINEAR_DETAIL_ALPHA_SGIS                                     0x8098
#endif //GL_LINEAR_DETAIL_ALPHA_SGIS
#ifndef GL_LINEAR_DETAIL_COLOR_SGIS
#define GL_LINEAR_DETAIL_COLOR_SGIS                                     0x8099
#endif //GL_LINEAR_DETAIL_COLOR_SGIS

#endif //GL_SGIS_detail_texture


typedef void (*PFNDETAILTEXFUNCSGISPROC_HPP)(GLenum target,GLsizei n,const GLfloat *points);

static inline void DetailTexFuncSGIS(GLenum target,GLsizei n,const GLfloat *points)
{
	static PFNDETAILTEXFUNCSGISPROC_HPP fn=reinterpret_cast<PFNDETAILTEXFUNCSGISPROC_HPP>(_impl::_get_proc_address("glDetailTexFuncSGIS","GL_SGIS_detail_texture"));
	 fn(target,n,points);
}

typedef void (*PFNGETDETAILTEXFUNCSGISPROC_HPP)(GLenum target,GLfloat *points);

static inline void GetDetailTexFuncSGIS(GLenum target,GLfloat *points)
{
	static PFNGETDETAILTEXFUNCSGISPROC_HPP fn=reinterpret_cast<PFNGETDETAILTEXFUNCSGISPROC_HPP>(_impl::_get_proc_address("glGetDetailTexFuncSGIS","GL_SGIS_detail_texture"));
	 fn(target,points);
}
#ifndef GL_SGIS_fog_function

#define GL_SGIS_fog_function

#endif //GL_SGIS_fog_function


typedef void (*PFNFOGFUNCSGISPROC_HPP)(GLsizei n,const GLfloat *points);

static inline void FogFuncSGIS(GLsizei n,const GLfloat *points)
{
	static PFNFOGFUNCSGISPROC_HPP fn=reinterpret_cast<PFNFOGFUNCSGISPROC_HPP>(_impl::_get_proc_address("glFogFuncSGIS","GL_SGIS_fog_function"));
	 fn(n,points);
}

typedef void (*PFNGETFOGFUNCSGISPROC_HPP)(GLfloat *points);

static inline void GetFogFuncSGIS(GLfloat *points)
{
	static PFNGETFOGFUNCSGISPROC_HPP fn=reinterpret_cast<PFNGETFOGFUNCSGISPROC_HPP>(_impl::_get_proc_address("glGetFogFuncSGIS","GL_SGIS_fog_function"));
	 fn(points);
}
#ifndef GL_SGIS_generate_mipmap

#define GL_SGIS_generate_mipmap

#endif //GL_SGIS_generate_mipmap

#ifndef GL_SGIS_multisample

#define GL_SGIS_multisample
#ifndef GL_1PASS_SGIS
#define GL_1PASS_SGIS                                                   0x80A1
#endif //GL_1PASS_SGIS
#ifndef GL_2PASS_0_SGIS
#define GL_2PASS_0_SGIS                                                 0x80A2
#endif //GL_2PASS_0_SGIS
#ifndef GL_2PASS_1_SGIS
#define GL_2PASS_1_SGIS                                                 0x80A3
#endif //GL_2PASS_1_SGIS
#ifndef GL_4PASS_0_SGIS
#define GL_4PASS_0_SGIS                                                 0x80A4
#endif //GL_4PASS_0_SGIS
#ifndef GL_4PASS_1_SGIS
#define GL_4PASS_1_SGIS                                                 0x80A5
#endif //GL_4PASS_1_SGIS
#ifndef GL_4PASS_2_SGIS
#define GL_4PASS_2_SGIS                                                 0x80A6
#endif //GL_4PASS_2_SGIS
#ifndef GL_4PASS_3_SGIS
#define GL_4PASS_3_SGIS                                                 0x80A7
#endif //GL_4PASS_3_SGIS

#endif //GL_SGIS_multisample


typedef void (*PFNSAMPLEMASKSGISPROC_HPP)(GLclampf value,GLboolean invert);

static inline void SampleMaskSGIS(GLclampf value,GLboolean invert)
{
	static PFNSAMPLEMASKSGISPROC_HPP fn=reinterpret_cast<PFNSAMPLEMASKSGISPROC_HPP>(_impl::_get_proc_address("glSampleMaskSGIS","GL_SGIS_multisample"));
	 fn(value,invert);
}

typedef void (*PFNSAMPLEPATTERNSGISPROC_HPP)(GLenum pattern);

static inline void SamplePatternSGIS(GLenum pattern)
{
	static PFNSAMPLEPATTERNSGISPROC_HPP fn=reinterpret_cast<PFNSAMPLEPATTERNSGISPROC_HPP>(_impl::_get_proc_address("glSamplePatternSGIS","GL_SGIS_multisample"));
	 fn(pattern);
}
#ifndef GL_SGIS_pixel_texture

#define GL_SGIS_pixel_texture
#ifndef GL_PIXEL_GROUP_COLOR_SGIS
#define GL_PIXEL_GROUP_COLOR_SGIS                                       0x8356
#endif //GL_PIXEL_GROUP_COLOR_SGIS

#endif //GL_SGIS_pixel_texture


typedef void (*PFNPIXELTEXGENPARAMETERISGISPROC_HPP)(GLenum pname,GLint param);

static inline void PixelTexGenParameteriSGIS(GLenum pname,GLint param)
{
	static PFNPIXELTEXGENPARAMETERISGISPROC_HPP fn=reinterpret_cast<PFNPIXELTEXGENPARAMETERISGISPROC_HPP>(_impl::_get_proc_address("glPixelTexGenParameteriSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,param);
}

typedef void (*PFNPIXELTEXGENPARAMETERIVSGISPROC_HPP)(GLenum pname,const GLint *params);

static inline void PixelTexGenParameterivSGIS(GLenum pname,const GLint *params)
{
	static PFNPIXELTEXGENPARAMETERIVSGISPROC_HPP fn=reinterpret_cast<PFNPIXELTEXGENPARAMETERIVSGISPROC_HPP>(_impl::_get_proc_address("glPixelTexGenParameterivSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,params);
}

typedef void (*PFNPIXELTEXGENPARAMETERFSGISPROC_HPP)(GLenum pname,GLfloat param);

static inline void PixelTexGenParameterfSGIS(GLenum pname,GLfloat param)
{
	static PFNPIXELTEXGENPARAMETERFSGISPROC_HPP fn=reinterpret_cast<PFNPIXELTEXGENPARAMETERFSGISPROC_HPP>(_impl::_get_proc_address("glPixelTexGenParameterfSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,param);
}

typedef void (*PFNPIXELTEXGENPARAMETERFVSGISPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void PixelTexGenParameterfvSGIS(GLenum pname,const GLfloat *params)
{
	static PFNPIXELTEXGENPARAMETERFVSGISPROC_HPP fn=reinterpret_cast<PFNPIXELTEXGENPARAMETERFVSGISPROC_HPP>(_impl::_get_proc_address("glPixelTexGenParameterfvSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,params);
}

typedef void (*PFNGETPIXELTEXGENPARAMETERIVSGISPROC_HPP)(GLenum pname,GLint *params);

static inline void GetPixelTexGenParameterivSGIS(GLenum pname,GLint *params)
{
	static PFNGETPIXELTEXGENPARAMETERIVSGISPROC_HPP fn=reinterpret_cast<PFNGETPIXELTEXGENPARAMETERIVSGISPROC_HPP>(_impl::_get_proc_address("glGetPixelTexGenParameterivSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,params);
}

typedef void (*PFNGETPIXELTEXGENPARAMETERFVSGISPROC_HPP)(GLenum pname,GLfloat *params);

static inline void GetPixelTexGenParameterfvSGIS(GLenum pname,GLfloat *params)
{
	static PFNGETPIXELTEXGENPARAMETERFVSGISPROC_HPP fn=reinterpret_cast<PFNGETPIXELTEXGENPARAMETERFVSGISPROC_HPP>(_impl::_get_proc_address("glGetPixelTexGenParameterfvSGIS","GL_SGIS_pixel_texture"));
	 fn(pname,params);
}
#ifndef GL_SGIS_point_line_texgen

#define GL_SGIS_point_line_texgen
#ifndef GL_EYE_DISTANCE_TO_POINT_SGIS
#define GL_EYE_DISTANCE_TO_POINT_SGIS                                   0x81F0
#endif //GL_EYE_DISTANCE_TO_POINT_SGIS
#ifndef GL_OBJECT_DISTANCE_TO_POINT_SGIS
#define GL_OBJECT_DISTANCE_TO_POINT_SGIS                                0x81F1
#endif //GL_OBJECT_DISTANCE_TO_POINT_SGIS
#ifndef GL_EYE_DISTANCE_TO_LINE_SGIS
#define GL_EYE_DISTANCE_TO_LINE_SGIS                                    0x81F2
#endif //GL_EYE_DISTANCE_TO_LINE_SGIS
#ifndef GL_OBJECT_DISTANCE_TO_LINE_SGIS
#define GL_OBJECT_DISTANCE_TO_LINE_SGIS                                 0x81F3
#endif //GL_OBJECT_DISTANCE_TO_LINE_SGIS
#ifndef GL_EYE_POINT_SGIS
#define GL_EYE_POINT_SGIS                                               0x81F4
#endif //GL_EYE_POINT_SGIS
#ifndef GL_OBJECT_POINT_SGIS
#define GL_OBJECT_POINT_SGIS                                            0x81F5
#endif //GL_OBJECT_POINT_SGIS
#ifndef GL_EYE_LINE_SGIS
#define GL_EYE_LINE_SGIS                                                0x81F6
#endif //GL_EYE_LINE_SGIS
#ifndef GL_OBJECT_LINE_SGIS
#define GL_OBJECT_LINE_SGIS                                             0x81F7
#endif //GL_OBJECT_LINE_SGIS

#endif //GL_SGIS_point_line_texgen

#ifndef GL_SGIS_point_parameters

#define GL_SGIS_point_parameters

#endif //GL_SGIS_point_parameters


typedef void (*PFNPOINTPARAMETERFSGISPROC_HPP)(GLenum pname,GLfloat param);

static inline void PointParameterfSGIS(GLenum pname,GLfloat param)
{
	static PFNPOINTPARAMETERFSGISPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFSGISPROC_HPP>(_impl::_get_proc_address("glPointParameterfSGIS","GL_SGIS_point_parameters"));
	 fn(pname,param);
}

typedef void (*PFNPOINTPARAMETERFVSGISPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void PointParameterfvSGIS(GLenum pname,const GLfloat *params)
{
	static PFNPOINTPARAMETERFVSGISPROC_HPP fn=reinterpret_cast<PFNPOINTPARAMETERFVSGISPROC_HPP>(_impl::_get_proc_address("glPointParameterfvSGIS","GL_SGIS_point_parameters"));
	 fn(pname,params);
}
#ifndef GL_SGIS_sharpen_texture

#define GL_SGIS_sharpen_texture
#ifndef GL_LINEAR_SHARPEN_SGIS
#define GL_LINEAR_SHARPEN_SGIS                                          0x80AD
#endif //GL_LINEAR_SHARPEN_SGIS
#ifndef GL_LINEAR_SHARPEN_ALPHA_SGIS
#define GL_LINEAR_SHARPEN_ALPHA_SGIS                                    0x80AE
#endif //GL_LINEAR_SHARPEN_ALPHA_SGIS
#ifndef GL_LINEAR_SHARPEN_COLOR_SGIS
#define GL_LINEAR_SHARPEN_COLOR_SGIS                                    0x80AF
#endif //GL_LINEAR_SHARPEN_COLOR_SGIS

#endif //GL_SGIS_sharpen_texture


typedef void (*PFNSHARPENTEXFUNCSGISPROC_HPP)(GLenum target,GLsizei n,const GLfloat *points);

static inline void SharpenTexFuncSGIS(GLenum target,GLsizei n,const GLfloat *points)
{
	static PFNSHARPENTEXFUNCSGISPROC_HPP fn=reinterpret_cast<PFNSHARPENTEXFUNCSGISPROC_HPP>(_impl::_get_proc_address("glSharpenTexFuncSGIS","GL_SGIS_sharpen_texture"));
	 fn(target,n,points);
}

typedef void (*PFNGETSHARPENTEXFUNCSGISPROC_HPP)(GLenum target,GLfloat *points);

static inline void GetSharpenTexFuncSGIS(GLenum target,GLfloat *points)
{
	static PFNGETSHARPENTEXFUNCSGISPROC_HPP fn=reinterpret_cast<PFNGETSHARPENTEXFUNCSGISPROC_HPP>(_impl::_get_proc_address("glGetSharpenTexFuncSGIS","GL_SGIS_sharpen_texture"));
	 fn(target,points);
}
#ifndef GL_SGIS_texture4D

#define GL_SGIS_texture4D
#ifndef GL_PROXY_TEXTURE_4D_SGIS
#define GL_PROXY_TEXTURE_4D_SGIS                                        0x8135
#endif //GL_PROXY_TEXTURE_4D_SGIS

#endif //GL_SGIS_texture4D


typedef void (*PFNTEXIMAGE4DSGISPROC_HPP)(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLint border,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexImage4DSGIS(GLenum target,GLint level,GLenum internalformat,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLint border,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXIMAGE4DSGISPROC_HPP fn=reinterpret_cast<PFNTEXIMAGE4DSGISPROC_HPP>(_impl::_get_proc_address("glTexImage4DSGIS","GL_SGIS_texture4D"));
	 fn(target,level,internalformat,width,height,depth,size4d,border,format,type,pixels);
}

typedef void (*PFNTEXSUBIMAGE4DSGISPROC_HPP)(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint woffset,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLenum format,GLenum type,const GLvoid *pixels);

static inline void TexSubImage4DSGIS(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLint woffset,GLsizei width,GLsizei height,GLsizei depth,GLsizei size4d,GLenum format,GLenum type,const GLvoid *pixels)
{
	static PFNTEXSUBIMAGE4DSGISPROC_HPP fn=reinterpret_cast<PFNTEXSUBIMAGE4DSGISPROC_HPP>(_impl::_get_proc_address("glTexSubImage4DSGIS","GL_SGIS_texture4D"));
	 fn(target,level,xoffset,yoffset,zoffset,woffset,width,height,depth,size4d,format,type,pixels);
}
#ifndef GL_SGIS_texture_border_clamp

#define GL_SGIS_texture_border_clamp
#ifndef GL_CLAMP_TO_BORDER_SGIS
#define GL_CLAMP_TO_BORDER_SGIS                                         0x812D
#endif //GL_CLAMP_TO_BORDER_SGIS

#endif //GL_SGIS_texture_border_clamp

#ifndef GL_SGIS_texture_color_mask

#define GL_SGIS_texture_color_mask
#ifndef GL_TEXTURE_COLOR_WRITEMASK_SGIS
#define GL_TEXTURE_COLOR_WRITEMASK_SGIS                                 0x81EF
#endif //GL_TEXTURE_COLOR_WRITEMASK_SGIS

#endif //GL_SGIS_texture_color_mask


typedef void (*PFNTEXTURECOLORMASKSGISPROC_HPP)(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha);

static inline void TextureColorMaskSGIS(GLboolean red,GLboolean green,GLboolean blue,GLboolean alpha)
{
	static PFNTEXTURECOLORMASKSGISPROC_HPP fn=reinterpret_cast<PFNTEXTURECOLORMASKSGISPROC_HPP>(_impl::_get_proc_address("glTextureColorMaskSGIS","GL_SGIS_texture_color_mask"));
	 fn(red,green,blue,alpha);
}
#ifndef GL_SGIS_texture_edge_clamp

#define GL_SGIS_texture_edge_clamp
#ifndef GL_CLAMP_TO_EDGE_SGIS
#define GL_CLAMP_TO_EDGE_SGIS                                           0x812F
#endif //GL_CLAMP_TO_EDGE_SGIS

#endif //GL_SGIS_texture_edge_clamp

#ifndef GL_SGIS_texture_filter4

#define GL_SGIS_texture_filter4
#ifndef GL_FILTER4_SGIS
#define GL_FILTER4_SGIS                                                 0x8146
#endif //GL_FILTER4_SGIS

#endif //GL_SGIS_texture_filter4


typedef void (*PFNGETTEXFILTERFUNCSGISPROC_HPP)(GLenum target,GLenum filter,GLfloat *weights);

static inline void GetTexFilterFuncSGIS(GLenum target,GLenum filter,GLfloat *weights)
{
	static PFNGETTEXFILTERFUNCSGISPROC_HPP fn=reinterpret_cast<PFNGETTEXFILTERFUNCSGISPROC_HPP>(_impl::_get_proc_address("glGetTexFilterFuncSGIS","GL_SGIS_texture_filter4"));
	 fn(target,filter,weights);
}

typedef void (*PFNTEXFILTERFUNCSGISPROC_HPP)(GLenum target,GLenum filter,GLsizei n,const GLfloat *weights);

static inline void TexFilterFuncSGIS(GLenum target,GLenum filter,GLsizei n,const GLfloat *weights)
{
	static PFNTEXFILTERFUNCSGISPROC_HPP fn=reinterpret_cast<PFNTEXFILTERFUNCSGISPROC_HPP>(_impl::_get_proc_address("glTexFilterFuncSGIS","GL_SGIS_texture_filter4"));
	 fn(target,filter,n,weights);
}
#ifndef GL_SGIS_texture_lod

#define GL_SGIS_texture_lod

#endif //GL_SGIS_texture_lod

#ifndef GL_SGIS_texture_select

#define GL_SGIS_texture_select

#endif //GL_SGIS_texture_select

#ifndef GL_SGIX_async

#define GL_SGIX_async

#endif //GL_SGIX_async


typedef void (*PFNASYNCMARKERSGIXPROC_HPP)(GLuint marker);

static inline void AsyncMarkerSGIX(GLuint marker)
{
	static PFNASYNCMARKERSGIXPROC_HPP fn=reinterpret_cast<PFNASYNCMARKERSGIXPROC_HPP>(_impl::_get_proc_address("glAsyncMarkerSGIX","GL_SGIX_async"));
	 fn(marker);
}

typedef GLint (*PFNFINISHASYNCSGIXPROC_HPP)(GLuint *markerp);

static inline GLint FinishAsyncSGIX(GLuint *markerp)
{
	static PFNFINISHASYNCSGIXPROC_HPP fn=reinterpret_cast<PFNFINISHASYNCSGIXPROC_HPP>(_impl::_get_proc_address("glFinishAsyncSGIX","GL_SGIX_async"));
	return fn(markerp);
}

typedef GLint (*PFNPOLLASYNCSGIXPROC_HPP)(GLuint *markerp);

static inline GLint PollAsyncSGIX(GLuint *markerp)
{
	static PFNPOLLASYNCSGIXPROC_HPP fn=reinterpret_cast<PFNPOLLASYNCSGIXPROC_HPP>(_impl::_get_proc_address("glPollAsyncSGIX","GL_SGIX_async"));
	return fn(markerp);
}

typedef GLuint (*PFNGENASYNCMARKERSSGIXPROC_HPP)(GLsizei range);

static inline GLuint GenAsyncMarkersSGIX(GLsizei range)
{
	static PFNGENASYNCMARKERSSGIXPROC_HPP fn=reinterpret_cast<PFNGENASYNCMARKERSSGIXPROC_HPP>(_impl::_get_proc_address("glGenAsyncMarkersSGIX","GL_SGIX_async"));
	return fn(range);
}

typedef void (*PFNDELETEASYNCMARKERSSGIXPROC_HPP)(GLuint marker,GLsizei range);

static inline void DeleteAsyncMarkersSGIX(GLuint marker,GLsizei range)
{
	static PFNDELETEASYNCMARKERSSGIXPROC_HPP fn=reinterpret_cast<PFNDELETEASYNCMARKERSSGIXPROC_HPP>(_impl::_get_proc_address("glDeleteAsyncMarkersSGIX","GL_SGIX_async"));
	 fn(marker,range);
}

typedef GLboolean (*PFNISASYNCMARKERSGIXPROC_HPP)(GLuint marker);

static inline GLboolean IsAsyncMarkerSGIX(GLuint marker)
{
	static PFNISASYNCMARKERSGIXPROC_HPP fn=reinterpret_cast<PFNISASYNCMARKERSGIXPROC_HPP>(_impl::_get_proc_address("glIsAsyncMarkerSGIX","GL_SGIX_async"));
	return fn(marker);
}
#ifndef GL_SGIX_async_histogram

#define GL_SGIX_async_histogram

#endif //GL_SGIX_async_histogram

#ifndef GL_SGIX_async_pixel

#define GL_SGIX_async_pixel

#endif //GL_SGIX_async_pixel

#ifndef GL_SGIX_blend_alpha_minmax

#define GL_SGIX_blend_alpha_minmax

#endif //GL_SGIX_blend_alpha_minmax

#ifndef GL_SGIX_calligraphic_fragment

#define GL_SGIX_calligraphic_fragment

#endif //GL_SGIX_calligraphic_fragment

#ifndef GL_SGIX_clipmap

#define GL_SGIX_clipmap
#ifndef GL_LINEAR_CLIPMAP_LINEAR_SGIX
#define GL_LINEAR_CLIPMAP_LINEAR_SGIX                                   0x8170
#endif //GL_LINEAR_CLIPMAP_LINEAR_SGIX
#ifndef GL_NEAREST_CLIPMAP_NEAREST_SGIX
#define GL_NEAREST_CLIPMAP_NEAREST_SGIX                                 0x844D
#endif //GL_NEAREST_CLIPMAP_NEAREST_SGIX
#ifndef GL_NEAREST_CLIPMAP_LINEAR_SGIX
#define GL_NEAREST_CLIPMAP_LINEAR_SGIX                                  0x844E
#endif //GL_NEAREST_CLIPMAP_LINEAR_SGIX
#ifndef GL_LINEAR_CLIPMAP_NEAREST_SGIX
#define GL_LINEAR_CLIPMAP_NEAREST_SGIX                                  0x844F
#endif //GL_LINEAR_CLIPMAP_NEAREST_SGIX

#endif //GL_SGIX_clipmap

#ifndef GL_SGIX_convolution_accuracy

#define GL_SGIX_convolution_accuracy

#endif //GL_SGIX_convolution_accuracy

#ifndef GL_SGIX_depth_pass_instrument

#define GL_SGIX_depth_pass_instrument
#ifndef GL_DEPTH_PASS_INSTRUMENT_SGIX
#define GL_DEPTH_PASS_INSTRUMENT_SGIX                                   0x8310
#endif //GL_DEPTH_PASS_INSTRUMENT_SGIX
#ifndef GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX
#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX                          0x8311
#endif //GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX
#ifndef GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX
#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX                               0x8312
#endif //GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX

#endif //GL_SGIX_depth_pass_instrument

#ifndef GL_SGIX_depth_texture

#define GL_SGIX_depth_texture

#endif //GL_SGIX_depth_texture

#ifndef GL_SGIX_flush_raster

#define GL_SGIX_flush_raster

#endif //GL_SGIX_flush_raster


typedef void (*PFNFLUSHRASTERSGIXPROC_HPP)();

static inline void FlushRasterSGIX()
{
	static PFNFLUSHRASTERSGIXPROC_HPP fn=reinterpret_cast<PFNFLUSHRASTERSGIXPROC_HPP>(_impl::_get_proc_address("glFlushRasterSGIX","GL_SGIX_flush_raster"));
	 fn();
}
#ifndef GL_SGIX_fog_offset

#define GL_SGIX_fog_offset

#endif //GL_SGIX_fog_offset

#ifndef GL_SGIX_fragment_lighting

#define GL_SGIX_fragment_lighting
#ifndef GL_CURRENT_RASTER_NORMAL_SGIX
#define GL_CURRENT_RASTER_NORMAL_SGIX                                   0x8406
#endif //GL_CURRENT_RASTER_NORMAL_SGIX

#endif //GL_SGIX_fragment_lighting


typedef void (*PFNFRAGMENTCOLORMATERIALSGIXPROC_HPP)(GLenum face,GLenum mode);

static inline void FragmentColorMaterialSGIX(GLenum face,GLenum mode)
{
	static PFNFRAGMENTCOLORMATERIALSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTCOLORMATERIALSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentColorMaterialSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,mode);
}

typedef void (*PFNFRAGMENTLIGHTFSGIXPROC_HPP)(GLenum light,GLenum pname,GLfloat param);

static inline void FragmentLightfSGIX(GLenum light,GLenum pname,GLfloat param)
{
	static PFNFRAGMENTLIGHTFSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTFSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightfSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,param);
}

typedef void (*PFNFRAGMENTLIGHTFVSGIXPROC_HPP)(GLenum light,GLenum pname,const GLfloat *params);

static inline void FragmentLightfvSGIX(GLenum light,GLenum pname,const GLfloat *params)
{
	static PFNFRAGMENTLIGHTFVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTFVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightfvSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,params);
}

typedef void (*PFNFRAGMENTLIGHTISGIXPROC_HPP)(GLenum light,GLenum pname,GLint param);

static inline void FragmentLightiSGIX(GLenum light,GLenum pname,GLint param)
{
	static PFNFRAGMENTLIGHTISGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTISGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightiSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,param);
}

typedef void (*PFNFRAGMENTLIGHTIVSGIXPROC_HPP)(GLenum light,GLenum pname,const GLint *params);

static inline void FragmentLightivSGIX(GLenum light,GLenum pname,const GLint *params)
{
	static PFNFRAGMENTLIGHTIVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTIVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightivSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,params);
}

typedef void (*PFNFRAGMENTLIGHTMODELFSGIXPROC_HPP)(GLenum pname,GLfloat param);

static inline void FragmentLightModelfSGIX(GLenum pname,GLfloat param)
{
	static PFNFRAGMENTLIGHTMODELFSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTMODELFSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightModelfSGIX","GL_SGIX_fragment_lighting"));
	 fn(pname,param);
}

typedef void (*PFNFRAGMENTLIGHTMODELFVSGIXPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void FragmentLightModelfvSGIX(GLenum pname,const GLfloat *params)
{
	static PFNFRAGMENTLIGHTMODELFVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTMODELFVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightModelfvSGIX","GL_SGIX_fragment_lighting"));
	 fn(pname,params);
}

typedef void (*PFNFRAGMENTLIGHTMODELISGIXPROC_HPP)(GLenum pname,GLint param);

static inline void FragmentLightModeliSGIX(GLenum pname,GLint param)
{
	static PFNFRAGMENTLIGHTMODELISGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTMODELISGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightModeliSGIX","GL_SGIX_fragment_lighting"));
	 fn(pname,param);
}

typedef void (*PFNFRAGMENTLIGHTMODELIVSGIXPROC_HPP)(GLenum pname,const GLint *params);

static inline void FragmentLightModelivSGIX(GLenum pname,const GLint *params)
{
	static PFNFRAGMENTLIGHTMODELIVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTLIGHTMODELIVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentLightModelivSGIX","GL_SGIX_fragment_lighting"));
	 fn(pname,params);
}

typedef void (*PFNFRAGMENTMATERIALFSGIXPROC_HPP)(GLenum face,GLenum pname,GLfloat param);

static inline void FragmentMaterialfSGIX(GLenum face,GLenum pname,GLfloat param)
{
	static PFNFRAGMENTMATERIALFSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTMATERIALFSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentMaterialfSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,param);
}

typedef void (*PFNFRAGMENTMATERIALFVSGIXPROC_HPP)(GLenum face,GLenum pname,const GLfloat *params);

static inline void FragmentMaterialfvSGIX(GLenum face,GLenum pname,const GLfloat *params)
{
	static PFNFRAGMENTMATERIALFVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTMATERIALFVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentMaterialfvSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,params);
}

typedef void (*PFNFRAGMENTMATERIALISGIXPROC_HPP)(GLenum face,GLenum pname,GLint param);

static inline void FragmentMaterialiSGIX(GLenum face,GLenum pname,GLint param)
{
	static PFNFRAGMENTMATERIALISGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTMATERIALISGIXPROC_HPP>(_impl::_get_proc_address("glFragmentMaterialiSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,param);
}

typedef void (*PFNFRAGMENTMATERIALIVSGIXPROC_HPP)(GLenum face,GLenum pname,const GLint *params);

static inline void FragmentMaterialivSGIX(GLenum face,GLenum pname,const GLint *params)
{
	static PFNFRAGMENTMATERIALIVSGIXPROC_HPP fn=reinterpret_cast<PFNFRAGMENTMATERIALIVSGIXPROC_HPP>(_impl::_get_proc_address("glFragmentMaterialivSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,params);
}

typedef void (*PFNGETFRAGMENTLIGHTFVSGIXPROC_HPP)(GLenum light,GLenum pname,GLfloat *params);

static inline void GetFragmentLightfvSGIX(GLenum light,GLenum pname,GLfloat *params)
{
	static PFNGETFRAGMENTLIGHTFVSGIXPROC_HPP fn=reinterpret_cast<PFNGETFRAGMENTLIGHTFVSGIXPROC_HPP>(_impl::_get_proc_address("glGetFragmentLightfvSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,params);
}

typedef void (*PFNGETFRAGMENTLIGHTIVSGIXPROC_HPP)(GLenum light,GLenum pname,GLint *params);

static inline void GetFragmentLightivSGIX(GLenum light,GLenum pname,GLint *params)
{
	static PFNGETFRAGMENTLIGHTIVSGIXPROC_HPP fn=reinterpret_cast<PFNGETFRAGMENTLIGHTIVSGIXPROC_HPP>(_impl::_get_proc_address("glGetFragmentLightivSGIX","GL_SGIX_fragment_lighting"));
	 fn(light,pname,params);
}

typedef void (*PFNGETFRAGMENTMATERIALFVSGIXPROC_HPP)(GLenum face,GLenum pname,GLfloat *params);

static inline void GetFragmentMaterialfvSGIX(GLenum face,GLenum pname,GLfloat *params)
{
	static PFNGETFRAGMENTMATERIALFVSGIXPROC_HPP fn=reinterpret_cast<PFNGETFRAGMENTMATERIALFVSGIXPROC_HPP>(_impl::_get_proc_address("glGetFragmentMaterialfvSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,params);
}

typedef void (*PFNGETFRAGMENTMATERIALIVSGIXPROC_HPP)(GLenum face,GLenum pname,GLint *params);

static inline void GetFragmentMaterialivSGIX(GLenum face,GLenum pname,GLint *params)
{
	static PFNGETFRAGMENTMATERIALIVSGIXPROC_HPP fn=reinterpret_cast<PFNGETFRAGMENTMATERIALIVSGIXPROC_HPP>(_impl::_get_proc_address("glGetFragmentMaterialivSGIX","GL_SGIX_fragment_lighting"));
	 fn(face,pname,params);
}

typedef void (*PFNLIGHTENVISGIXPROC_HPP)(GLenum pname,GLint param);

static inline void LightEnviSGIX(GLenum pname,GLint param)
{
	static PFNLIGHTENVISGIXPROC_HPP fn=reinterpret_cast<PFNLIGHTENVISGIXPROC_HPP>(_impl::_get_proc_address("glLightEnviSGIX","GL_SGIX_fragment_lighting"));
	 fn(pname,param);
}
#ifndef GL_SGIX_fragments_instrument

#define GL_SGIX_fragments_instrument
#ifndef GL_FRAGMENTS_INSTRUMENT_SGIX
#define GL_FRAGMENTS_INSTRUMENT_SGIX                                    0x8313
#endif //GL_FRAGMENTS_INSTRUMENT_SGIX
#ifndef GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX
#define GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX                           0x8314
#endif //GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX
#ifndef GL_FRAGMENTS_INSTRUMENT_MAX_SGIX
#define GL_FRAGMENTS_INSTRUMENT_MAX_SGIX                                0x8315
#endif //GL_FRAGMENTS_INSTRUMENT_MAX_SGIX

#endif //GL_SGIX_fragments_instrument

#ifndef GL_SGIX_framezoom

#define GL_SGIX_framezoom

#endif //GL_SGIX_framezoom


typedef void (*PFNFRAMEZOOMSGIXPROC_HPP)(GLint factor);

static inline void FrameZoomSGIX(GLint factor)
{
	static PFNFRAMEZOOMSGIXPROC_HPP fn=reinterpret_cast<PFNFRAMEZOOMSGIXPROC_HPP>(_impl::_get_proc_address("glFrameZoomSGIX","GL_SGIX_framezoom"));
	 fn(factor);
}
#ifndef GL_SGIX_igloo_interface

#define GL_SGIX_igloo_interface

#endif //GL_SGIX_igloo_interface


typedef void (*PFNIGLOOINTERFACESGIXPROC_HPP)(GLenum pname,const GLvoid *params);

static inline void IglooInterfaceSGIX(GLenum pname,const GLvoid *params)
{
	static PFNIGLOOINTERFACESGIXPROC_HPP fn=reinterpret_cast<PFNIGLOOINTERFACESGIXPROC_HPP>(_impl::_get_proc_address("glIglooInterfaceSGIX","GL_SGIX_igloo_interface"));
	 fn(pname,params);
}
#ifndef GL_SGIX_impact_pixel_texture

#define GL_SGIX_impact_pixel_texture
#ifndef GL_PIXEL_TEX_GEN_Q_CEILING_SGIX
#define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX                                 0x8184
#endif //GL_PIXEL_TEX_GEN_Q_CEILING_SGIX
#ifndef GL_PIXEL_TEX_GEN_Q_ROUND_SGIX
#define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX                                   0x8185
#endif //GL_PIXEL_TEX_GEN_Q_ROUND_SGIX
#ifndef GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX
#define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX                                   0x8186
#endif //GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX

#endif //GL_SGIX_impact_pixel_texture

#ifndef GL_SGIX_instruments

#define GL_SGIX_instruments

#endif //GL_SGIX_instruments


typedef GLint (*PFNGETINSTRUMENTSSGIXPROC_HPP)();

static inline GLint GetInstrumentsSGIX()
{
	static PFNGETINSTRUMENTSSGIXPROC_HPP fn=reinterpret_cast<PFNGETINSTRUMENTSSGIXPROC_HPP>(_impl::_get_proc_address("glGetInstrumentsSGIX","GL_SGIX_instruments"));
	return fn();
}

typedef void (*PFNINSTRUMENTSBUFFERSGIXPROC_HPP)(GLsizei size,GLint *buffer);

static inline void InstrumentsBufferSGIX(GLsizei size,GLint *buffer)
{
	static PFNINSTRUMENTSBUFFERSGIXPROC_HPP fn=reinterpret_cast<PFNINSTRUMENTSBUFFERSGIXPROC_HPP>(_impl::_get_proc_address("glInstrumentsBufferSGIX","GL_SGIX_instruments"));
	 fn(size,buffer);
}

typedef GLint (*PFNPOLLINSTRUMENTSSGIXPROC_HPP)(GLint *marker_p);

static inline GLint PollInstrumentsSGIX(GLint *marker_p)
{
	static PFNPOLLINSTRUMENTSSGIXPROC_HPP fn=reinterpret_cast<PFNPOLLINSTRUMENTSSGIXPROC_HPP>(_impl::_get_proc_address("glPollInstrumentsSGIX","GL_SGIX_instruments"));
	return fn(marker_p);
}

typedef void (*PFNREADINSTRUMENTSSGIXPROC_HPP)(GLint marker);

static inline void ReadInstrumentsSGIX(GLint marker)
{
	static PFNREADINSTRUMENTSSGIXPROC_HPP fn=reinterpret_cast<PFNREADINSTRUMENTSSGIXPROC_HPP>(_impl::_get_proc_address("glReadInstrumentsSGIX","GL_SGIX_instruments"));
	 fn(marker);
}

typedef void (*PFNSTARTINSTRUMENTSSGIXPROC_HPP)();

static inline void StartInstrumentsSGIX()
{
	static PFNSTARTINSTRUMENTSSGIXPROC_HPP fn=reinterpret_cast<PFNSTARTINSTRUMENTSSGIXPROC_HPP>(_impl::_get_proc_address("glStartInstrumentsSGIX","GL_SGIX_instruments"));
	 fn();
}

typedef void (*PFNSTOPINSTRUMENTSSGIXPROC_HPP)(GLint marker);

static inline void StopInstrumentsSGIX(GLint marker)
{
	static PFNSTOPINSTRUMENTSSGIXPROC_HPP fn=reinterpret_cast<PFNSTOPINSTRUMENTSSGIXPROC_HPP>(_impl::_get_proc_address("glStopInstrumentsSGIX","GL_SGIX_instruments"));
	 fn(marker);
}
#ifndef GL_SGIX_interlace

#define GL_SGIX_interlace

#endif //GL_SGIX_interlace

#ifndef GL_SGIX_ir_instrument1

#define GL_SGIX_ir_instrument1

#endif //GL_SGIX_ir_instrument1

#ifndef GL_SGIX_line_quality_hint

#define GL_SGIX_line_quality_hint
#ifndef GL_LINE_QUALITY_HINT_SGIX
#define GL_LINE_QUALITY_HINT_SGIX                                       0x835B
#endif //GL_LINE_QUALITY_HINT_SGIX

#endif //GL_SGIX_line_quality_hint

#ifndef GL_SGIX_list_priority

#define GL_SGIX_list_priority

#endif //GL_SGIX_list_priority


typedef void (*PFNGETLISTPARAMETERFVSGIXPROC_HPP)(GLuint list,GLenum pname,GLfloat *params);

static inline void GetListParameterfvSGIX(GLuint list,GLenum pname,GLfloat *params)
{
	static PFNGETLISTPARAMETERFVSGIXPROC_HPP fn=reinterpret_cast<PFNGETLISTPARAMETERFVSGIXPROC_HPP>(_impl::_get_proc_address("glGetListParameterfvSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,params);
}

typedef void (*PFNGETLISTPARAMETERIVSGIXPROC_HPP)(GLuint list,GLenum pname,GLint *params);

static inline void GetListParameterivSGIX(GLuint list,GLenum pname,GLint *params)
{
	static PFNGETLISTPARAMETERIVSGIXPROC_HPP fn=reinterpret_cast<PFNGETLISTPARAMETERIVSGIXPROC_HPP>(_impl::_get_proc_address("glGetListParameterivSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,params);
}

typedef void (*PFNLISTPARAMETERFSGIXPROC_HPP)(GLuint list,GLenum pname,GLfloat param);

static inline void ListParameterfSGIX(GLuint list,GLenum pname,GLfloat param)
{
	static PFNLISTPARAMETERFSGIXPROC_HPP fn=reinterpret_cast<PFNLISTPARAMETERFSGIXPROC_HPP>(_impl::_get_proc_address("glListParameterfSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,param);
}

typedef void (*PFNLISTPARAMETERFVSGIXPROC_HPP)(GLuint list,GLenum pname,const GLfloat *params);

static inline void ListParameterfvSGIX(GLuint list,GLenum pname,const GLfloat *params)
{
	static PFNLISTPARAMETERFVSGIXPROC_HPP fn=reinterpret_cast<PFNLISTPARAMETERFVSGIXPROC_HPP>(_impl::_get_proc_address("glListParameterfvSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,params);
}

typedef void (*PFNLISTPARAMETERISGIXPROC_HPP)(GLuint list,GLenum pname,GLint param);

static inline void ListParameteriSGIX(GLuint list,GLenum pname,GLint param)
{
	static PFNLISTPARAMETERISGIXPROC_HPP fn=reinterpret_cast<PFNLISTPARAMETERISGIXPROC_HPP>(_impl::_get_proc_address("glListParameteriSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,param);
}

typedef void (*PFNLISTPARAMETERIVSGIXPROC_HPP)(GLuint list,GLenum pname,const GLint *params);

static inline void ListParameterivSGIX(GLuint list,GLenum pname,const GLint *params)
{
	static PFNLISTPARAMETERIVSGIXPROC_HPP fn=reinterpret_cast<PFNLISTPARAMETERIVSGIXPROC_HPP>(_impl::_get_proc_address("glListParameterivSGIX","GL_SGIX_list_priority"));
	 fn(list,pname,params);
}
#ifndef GL_SGIX_pixel_texture

#define GL_SGIX_pixel_texture

#endif //GL_SGIX_pixel_texture


typedef void (*PFNPIXELTEXGENSGIXPROC_HPP)(GLenum mode);

static inline void PixelTexGenSGIX(GLenum mode)
{
	static PFNPIXELTEXGENSGIXPROC_HPP fn=reinterpret_cast<PFNPIXELTEXGENSGIXPROC_HPP>(_impl::_get_proc_address("glPixelTexGenSGIX","GL_SGIX_pixel_texture"));
	 fn(mode);
}
#ifndef GL_SGIX_pixel_tiles

#define GL_SGIX_pixel_tiles

#endif //GL_SGIX_pixel_tiles

#ifndef GL_SGIX_polynomial_ffd

#define GL_SGIX_polynomial_ffd
#ifndef GL_MAX_DEFORMATION_ORDER_SGIX
#define GL_MAX_DEFORMATION_ORDER_SGIX                                   0x8197
#endif //GL_MAX_DEFORMATION_ORDER_SGIX

#endif //GL_SGIX_polynomial_ffd


typedef void (*PFNDEFORMATIONMAP3DSGIXPROC_HPP)(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,GLdouble w1,GLdouble w2,GLint wstride,GLint worder,const GLdouble *points);

static inline void DeformationMap3dSGIX(GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,GLdouble w1,GLdouble w2,GLint wstride,GLint worder,const GLdouble *points)
{
	static PFNDEFORMATIONMAP3DSGIXPROC_HPP fn=reinterpret_cast<PFNDEFORMATIONMAP3DSGIXPROC_HPP>(_impl::_get_proc_address("glDeformationMap3dSGIX","GL_SGIX_polynomial_ffd"));
	 fn(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,w1,w2,wstride,worder,points);
}

typedef void (*PFNDEFORMATIONMAP3FSGIXPROC_HPP)(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,GLfloat w1,GLfloat w2,GLint wstride,GLint worder,const GLfloat *points);

static inline void DeformationMap3fSGIX(GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,GLfloat w1,GLfloat w2,GLint wstride,GLint worder,const GLfloat *points)
{
	static PFNDEFORMATIONMAP3FSGIXPROC_HPP fn=reinterpret_cast<PFNDEFORMATIONMAP3FSGIXPROC_HPP>(_impl::_get_proc_address("glDeformationMap3fSGIX","GL_SGIX_polynomial_ffd"));
	 fn(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,w1,w2,wstride,worder,points);
}

typedef void (*PFNDEFORMSGIXPROC_HPP)(GLbitfield mask);

static inline void DeformSGIX(GLbitfield mask)
{
	static PFNDEFORMSGIXPROC_HPP fn=reinterpret_cast<PFNDEFORMSGIXPROC_HPP>(_impl::_get_proc_address("glDeformSGIX","GL_SGIX_polynomial_ffd"));
	 fn(mask);
}

typedef void (*PFNLOADIDENTITYDEFORMATIONMAPSGIXPROC_HPP)(GLbitfield mask);

static inline void LoadIdentityDeformationMapSGIX(GLbitfield mask)
{
	static PFNLOADIDENTITYDEFORMATIONMAPSGIXPROC_HPP fn=reinterpret_cast<PFNLOADIDENTITYDEFORMATIONMAPSGIXPROC_HPP>(_impl::_get_proc_address("glLoadIdentityDeformationMapSGIX","GL_SGIX_polynomial_ffd"));
	 fn(mask);
}
#ifndef GL_SGIX_reference_plane

#define GL_SGIX_reference_plane

#endif //GL_SGIX_reference_plane


typedef void (*PFNREFERENCEPLANESGIXPROC_HPP)(const GLdouble *equation);

static inline void ReferencePlaneSGIX(const GLdouble *equation)
{
	static PFNREFERENCEPLANESGIXPROC_HPP fn=reinterpret_cast<PFNREFERENCEPLANESGIXPROC_HPP>(_impl::_get_proc_address("glReferencePlaneSGIX","GL_SGIX_reference_plane"));
	 fn(equation);
}
#ifndef GL_SGIX_resample

#define GL_SGIX_resample

#endif //GL_SGIX_resample

#ifndef GL_SGIX_scalebias_hint

#define GL_SGIX_scalebias_hint
#ifndef GL_SCALEBIAS_HINT_SGIX
#define GL_SCALEBIAS_HINT_SGIX                                          0x8322
#endif //GL_SCALEBIAS_HINT_SGIX

#endif //GL_SGIX_scalebias_hint

#ifndef GL_SGIX_shadow

#define GL_SGIX_shadow

#endif //GL_SGIX_shadow

#ifndef GL_SGIX_shadow_ambient

#define GL_SGIX_shadow_ambient

#endif //GL_SGIX_shadow_ambient

#ifndef GL_SGIX_slim

#define GL_SGIX_slim
#ifndef GL_UNPACK_COMPRESSED_SIZE_SGIX
#define GL_UNPACK_COMPRESSED_SIZE_SGIX                                  0x831A
#endif //GL_UNPACK_COMPRESSED_SIZE_SGIX
#ifndef GL_PACK_MAX_COMPRESSED_SIZE_SGIX
#define GL_PACK_MAX_COMPRESSED_SIZE_SGIX                                0x831B
#endif //GL_PACK_MAX_COMPRESSED_SIZE_SGIX
#ifndef GL_PACK_COMPRESSED_SIZE_SGIX
#define GL_PACK_COMPRESSED_SIZE_SGIX                                    0x831C
#endif //GL_PACK_COMPRESSED_SIZE_SGIX
#ifndef GL_SLIM8U_SGIX
#define GL_SLIM8U_SGIX                                                  0x831D
#endif //GL_SLIM8U_SGIX
#ifndef GL_SLIM10U_SGIX
#define GL_SLIM10U_SGIX                                                 0x831E
#endif //GL_SLIM10U_SGIX
#ifndef GL_SLIM12S_SGIX
#define GL_SLIM12S_SGIX                                                 0x831F
#endif //GL_SLIM12S_SGIX

#endif //GL_SGIX_slim

#ifndef GL_SGIX_sprite

#define GL_SGIX_sprite
#ifndef GL_SPRITE_AXIAL_SGIX
#define GL_SPRITE_AXIAL_SGIX                                            0x814C
#endif //GL_SPRITE_AXIAL_SGIX
#ifndef GL_SPRITE_OBJECT_ALIGNED_SGIX
#define GL_SPRITE_OBJECT_ALIGNED_SGIX                                   0x814D
#endif //GL_SPRITE_OBJECT_ALIGNED_SGIX
#ifndef GL_SPRITE_EYE_ALIGNED_SGIX
#define GL_SPRITE_EYE_ALIGNED_SGIX                                      0x814E
#endif //GL_SPRITE_EYE_ALIGNED_SGIX

#endif //GL_SGIX_sprite


typedef void (*PFNSPRITEPARAMETERFSGIXPROC_HPP)(GLenum pname,GLfloat param);

static inline void SpriteParameterfSGIX(GLenum pname,GLfloat param)
{
	static PFNSPRITEPARAMETERFSGIXPROC_HPP fn=reinterpret_cast<PFNSPRITEPARAMETERFSGIXPROC_HPP>(_impl::_get_proc_address("glSpriteParameterfSGIX","GL_SGIX_sprite"));
	 fn(pname,param);
}

typedef void (*PFNSPRITEPARAMETERFVSGIXPROC_HPP)(GLenum pname,const GLfloat *params);

static inline void SpriteParameterfvSGIX(GLenum pname,const GLfloat *params)
{
	static PFNSPRITEPARAMETERFVSGIXPROC_HPP fn=reinterpret_cast<PFNSPRITEPARAMETERFVSGIXPROC_HPP>(_impl::_get_proc_address("glSpriteParameterfvSGIX","GL_SGIX_sprite"));
	 fn(pname,params);
}

typedef void (*PFNSPRITEPARAMETERISGIXPROC_HPP)(GLenum pname,GLint param);

static inline void SpriteParameteriSGIX(GLenum pname,GLint param)
{
	static PFNSPRITEPARAMETERISGIXPROC_HPP fn=reinterpret_cast<PFNSPRITEPARAMETERISGIXPROC_HPP>(_impl::_get_proc_address("glSpriteParameteriSGIX","GL_SGIX_sprite"));
	 fn(pname,param);
}

typedef void (*PFNSPRITEPARAMETERIVSGIXPROC_HPP)(GLenum pname,const GLint *params);

static inline void SpriteParameterivSGIX(GLenum pname,const GLint *params)
{
	static PFNSPRITEPARAMETERIVSGIXPROC_HPP fn=reinterpret_cast<PFNSPRITEPARAMETERIVSGIXPROC_HPP>(_impl::_get_proc_address("glSpriteParameterivSGIX","GL_SGIX_sprite"));
	 fn(pname,params);
}
#ifndef GL_SGIX_subsample

#define GL_SGIX_subsample

#endif //GL_SGIX_subsample

#ifndef GL_SGIX_tag_sample_buffer

#define GL_SGIX_tag_sample_buffer

#endif //GL_SGIX_tag_sample_buffer


typedef void (*PFNTAGSAMPLEBUFFERSGIXPROC_HPP)();

static inline void TagSampleBufferSGIX()
{
	static PFNTAGSAMPLEBUFFERSGIXPROC_HPP fn=reinterpret_cast<PFNTAGSAMPLEBUFFERSGIXPROC_HPP>(_impl::_get_proc_address("glTagSampleBufferSGIX","GL_SGIX_tag_sample_buffer"));
	 fn();
}
#ifndef GL_SGIX_texture_add_env

#define GL_SGIX_texture_add_env
#ifndef GL_TEXTURE_ENV_BIAS_SGIX
#define GL_TEXTURE_ENV_BIAS_SGIX                                        0x80BE
#endif //GL_TEXTURE_ENV_BIAS_SGIX

#endif //GL_SGIX_texture_add_env

#ifndef GL_SGIX_texture_coordinate_clamp

#define GL_SGIX_texture_coordinate_clamp
#ifndef GL_FOG_FACTOR_TO_ALPHA_SGIX
#define GL_FOG_FACTOR_TO_ALPHA_SGIX                                     0x836F
#endif //GL_FOG_FACTOR_TO_ALPHA_SGIX

#endif //GL_SGIX_texture_coordinate_clamp

#ifndef GL_SGIX_texture_lod_bias

#define GL_SGIX_texture_lod_bias

#endif //GL_SGIX_texture_lod_bias

#ifndef GL_SGIX_texture_multi_buffer

#define GL_SGIX_texture_multi_buffer

#endif //GL_SGIX_texture_multi_buffer

#ifndef GL_SGIX_texture_scale_bias

#define GL_SGIX_texture_scale_bias

#endif //GL_SGIX_texture_scale_bias

#ifndef GL_SGIX_vertex_preclip

#define GL_SGIX_vertex_preclip

#endif //GL_SGIX_vertex_preclip

#ifndef GL_SGIX_ycrcb

#define GL_SGIX_ycrcb

#endif //GL_SGIX_ycrcb

#ifndef GL_SGIX_ycrcba

#define GL_SGIX_ycrcba
#ifndef GL_YCRCB_SGIX
#define GL_YCRCB_SGIX                                                   0x8318
#endif //GL_YCRCB_SGIX
#ifndef GL_YCRCBA_SGIX
#define GL_YCRCBA_SGIX                                                  0x8319
#endif //GL_YCRCBA_SGIX

#endif //GL_SGIX_ycrcba

#ifndef GL_SGI_color_matrix

#define GL_SGI_color_matrix

#endif //GL_SGI_color_matrix

#ifndef GL_SGI_color_table

#define GL_SGI_color_table

#endif //GL_SGI_color_table


typedef void (*PFNCOLORTABLESGIPROC_HPP)(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *table);

static inline void ColorTableSGI(GLenum target,GLenum internalformat,GLsizei width,GLenum format,GLenum type,const GLvoid *table)
{
	static PFNCOLORTABLESGIPROC_HPP fn=reinterpret_cast<PFNCOLORTABLESGIPROC_HPP>(_impl::_get_proc_address("glColorTableSGI","GL_SGI_color_table"));
	 fn(target,internalformat,width,format,type,table);
}

typedef void (*PFNCOLORTABLEPARAMETERFVSGIPROC_HPP)(GLenum target,GLenum pname,const GLfloat *params);

static inline void ColorTableParameterfvSGI(GLenum target,GLenum pname,const GLfloat *params)
{
	static PFNCOLORTABLEPARAMETERFVSGIPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEPARAMETERFVSGIPROC_HPP>(_impl::_get_proc_address("glColorTableParameterfvSGI","GL_SGI_color_table"));
	 fn(target,pname,params);
}

typedef void (*PFNCOLORTABLEPARAMETERIVSGIPROC_HPP)(GLenum target,GLenum pname,const GLint *params);

static inline void ColorTableParameterivSGI(GLenum target,GLenum pname,const GLint *params)
{
	static PFNCOLORTABLEPARAMETERIVSGIPROC_HPP fn=reinterpret_cast<PFNCOLORTABLEPARAMETERIVSGIPROC_HPP>(_impl::_get_proc_address("glColorTableParameterivSGI","GL_SGI_color_table"));
	 fn(target,pname,params);
}

typedef void (*PFNCOPYCOLORTABLESGIPROC_HPP)(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width);

static inline void CopyColorTableSGI(GLenum target,GLenum internalformat,GLint x,GLint y,GLsizei width)
{
	static PFNCOPYCOLORTABLESGIPROC_HPP fn=reinterpret_cast<PFNCOPYCOLORTABLESGIPROC_HPP>(_impl::_get_proc_address("glCopyColorTableSGI","GL_SGI_color_table"));
	 fn(target,internalformat,x,y,width);
}

typedef void (*PFNGETCOLORTABLESGIPROC_HPP)(GLenum target,GLenum format,GLenum type,GLvoid *table);

static inline void GetColorTableSGI(GLenum target,GLenum format,GLenum type,GLvoid *table)
{
	static PFNGETCOLORTABLESGIPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLESGIPROC_HPP>(_impl::_get_proc_address("glGetColorTableSGI","GL_SGI_color_table"));
	 fn(target,format,type,table);
}

typedef void (*PFNGETCOLORTABLEPARAMETERFVSGIPROC_HPP)(GLenum target,GLenum pname,GLfloat *params);

static inline void GetColorTableParameterfvSGI(GLenum target,GLenum pname,GLfloat *params)
{
	static PFNGETCOLORTABLEPARAMETERFVSGIPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERFVSGIPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameterfvSGI","GL_SGI_color_table"));
	 fn(target,pname,params);
}

typedef void (*PFNGETCOLORTABLEPARAMETERIVSGIPROC_HPP)(GLenum target,GLenum pname,GLint *params);

static inline void GetColorTableParameterivSGI(GLenum target,GLenum pname,GLint *params)
{
	static PFNGETCOLORTABLEPARAMETERIVSGIPROC_HPP fn=reinterpret_cast<PFNGETCOLORTABLEPARAMETERIVSGIPROC_HPP>(_impl::_get_proc_address("glGetColorTableParameterivSGI","GL_SGI_color_table"));
	 fn(target,pname,params);
}
#ifndef GL_SGI_texture_color_table

#define GL_SGI_texture_color_table

#endif //GL_SGI_texture_color_table

#ifndef GL_SUNX_constant_data

#define GL_SUNX_constant_data
#ifndef GL_UNPACK_CONSTANT_DATA_SUNX
#define GL_UNPACK_CONSTANT_DATA_SUNX                                    0x81D5
#endif //GL_UNPACK_CONSTANT_DATA_SUNX
#ifndef GL_TEXTURE_CONSTANT_DATA_SUNX
#define GL_TEXTURE_CONSTANT_DATA_SUNX                                   0x81D6
#endif //GL_TEXTURE_CONSTANT_DATA_SUNX

#endif //GL_SUNX_constant_data


typedef void (*PFNFINISHTEXTURESUNXPROC_HPP)();

static inline void FinishTextureSUNX()
{
	static PFNFINISHTEXTURESUNXPROC_HPP fn=reinterpret_cast<PFNFINISHTEXTURESUNXPROC_HPP>(_impl::_get_proc_address("glFinishTextureSUNX","GL_SUNX_constant_data"));
	 fn();
}
#ifndef GL_SUNX_general_triangle_list

#define GL_SUNX_general_triangle_list
#ifndef GL_RESTART_SUN
#define GL_RESTART_SUN                                                  0x0001
#endif //GL_RESTART_SUN
#ifndef GL_REPLACE_MIDDLE_SUN
#define GL_REPLACE_MIDDLE_SUN                                           0x0002
#endif //GL_REPLACE_MIDDLE_SUN
#ifndef GL_REPLACE_OLDEST_SUN
#define GL_REPLACE_OLDEST_SUN                                           0x0003
#endif //GL_REPLACE_OLDEST_SUN
#ifndef GL_WRAP_BORDER_SUN
#define GL_WRAP_BORDER_SUN                                              0x81D4
#endif //GL_WRAP_BORDER_SUN
#ifndef GL_TRIANGLE_LIST_SUN
#define GL_TRIANGLE_LIST_SUN                                            0x81D7
#endif //GL_TRIANGLE_LIST_SUN
#ifndef GL_REPLACEMENT_CODE_SUN
#define GL_REPLACEMENT_CODE_SUN                                         0x81D8
#endif //GL_REPLACEMENT_CODE_SUN
#ifndef GL_REPLACEMENT_CODE_ARRAY_SUN
#define GL_REPLACEMENT_CODE_ARRAY_SUN                                   0x85C0
#endif //GL_REPLACEMENT_CODE_ARRAY_SUN
#ifndef GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN
#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN                              0x85C1
#endif //GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN
#ifndef GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN
#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN                            0x85C2
#endif //GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN
#ifndef GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN
#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN                           0x85C3
#endif //GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN
#ifndef GL_R1UI_V3F_SUN
#define GL_R1UI_V3F_SUN                                                 0x85C4
#endif //GL_R1UI_V3F_SUN
#ifndef GL_R1UI_C4UB_V3F_SUN
#define GL_R1UI_C4UB_V3F_SUN                                            0x85C5
#endif //GL_R1UI_C4UB_V3F_SUN
#ifndef GL_R1UI_C3F_V3F_SUN
#define GL_R1UI_C3F_V3F_SUN                                             0x85C6
#endif //GL_R1UI_C3F_V3F_SUN
#ifndef GL_R1UI_N3F_V3F_SUN
#define GL_R1UI_N3F_V3F_SUN                                             0x85C7
#endif //GL_R1UI_N3F_V3F_SUN
#ifndef GL_R1UI_C4F_N3F_V3F_SUN
#define GL_R1UI_C4F_N3F_V3F_SUN                                         0x85C8
#endif //GL_R1UI_C4F_N3F_V3F_SUN
#ifndef GL_R1UI_T2F_V3F_SUN
#define GL_R1UI_T2F_V3F_SUN                                             0x85C9
#endif //GL_R1UI_T2F_V3F_SUN
#ifndef GL_R1UI_T2F_N3F_V3F_SUN
#define GL_R1UI_T2F_N3F_V3F_SUN                                         0x85CA
#endif //GL_R1UI_T2F_N3F_V3F_SUN
#ifndef GL_R1UI_T2F_C4F_N3F_V3F_SUN
#define GL_R1UI_T2F_C4F_N3F_V3F_SUN                                     0x85CB
#endif //GL_R1UI_T2F_C4F_N3F_V3F_SUN

#endif //GL_SUNX_general_triangle_list

#ifndef GL_SUN_global_alpha

#define GL_SUN_global_alpha
#ifndef GL_GLOBAL_ALPHA_SUN
#define GL_GLOBAL_ALPHA_SUN                                             0x81D9
#endif //GL_GLOBAL_ALPHA_SUN
#ifndef GL_GLOBAL_ALPHA_FACTOR_SUN
#define GL_GLOBAL_ALPHA_FACTOR_SUN                                      0x81DA
#endif //GL_GLOBAL_ALPHA_FACTOR_SUN

#endif //GL_SUN_global_alpha


typedef void (*PFNGLOBALALPHAFACTORBSUNPROC_HPP)(GLbyte factor);

static inline void GlobalAlphaFactorbSUN(GLbyte factor)
{
	static PFNGLOBALALPHAFACTORBSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORBSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactorbSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORSSUNPROC_HPP)(GLshort factor);

static inline void GlobalAlphaFactorsSUN(GLshort factor)
{
	static PFNGLOBALALPHAFACTORSSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORSSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactorsSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORISUNPROC_HPP)(GLint factor);

static inline void GlobalAlphaFactoriSUN(GLint factor)
{
	static PFNGLOBALALPHAFACTORISUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORISUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactoriSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORFSUNPROC_HPP)(GLfloat factor);

static inline void GlobalAlphaFactorfSUN(GLfloat factor)
{
	static PFNGLOBALALPHAFACTORFSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORFSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactorfSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORDSUNPROC_HPP)(GLdouble factor);

static inline void GlobalAlphaFactordSUN(GLdouble factor)
{
	static PFNGLOBALALPHAFACTORDSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORDSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactordSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORUBSUNPROC_HPP)(GLubyte factor);

static inline void GlobalAlphaFactorubSUN(GLubyte factor)
{
	static PFNGLOBALALPHAFACTORUBSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORUBSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactorubSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORUSSUNPROC_HPP)(GLushort factor);

static inline void GlobalAlphaFactorusSUN(GLushort factor)
{
	static PFNGLOBALALPHAFACTORUSSUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORUSSUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactorusSUN","GL_SUN_global_alpha"));
	 fn(factor);
}

typedef void (*PFNGLOBALALPHAFACTORUISUNPROC_HPP)(GLuint factor);

static inline void GlobalAlphaFactoruiSUN(GLuint factor)
{
	static PFNGLOBALALPHAFACTORUISUNPROC_HPP fn=reinterpret_cast<PFNGLOBALALPHAFACTORUISUNPROC_HPP>(_impl::_get_proc_address("glGlobalAlphaFactoruiSUN","GL_SUN_global_alpha"));
	 fn(factor);
}
#ifndef GL_SUN_mesh_array

#define GL_SUN_mesh_array
#ifndef GL_QUAD_MESH_SUN
#define GL_QUAD_MESH_SUN                                                0x8614
#endif //GL_QUAD_MESH_SUN
#ifndef GL_TRIANGLE_MESH_SUN
#define GL_TRIANGLE_MESH_SUN                                            0x8615
#endif //GL_TRIANGLE_MESH_SUN

#endif //GL_SUN_mesh_array


typedef void (*PFNDRAWMESHARRAYSSUNPROC_HPP)(GLenum mode,GLint first,GLsizei count,GLsizei width);

static inline void DrawMeshArraysSUN(GLenum mode,GLint first,GLsizei count,GLsizei width)
{
	static PFNDRAWMESHARRAYSSUNPROC_HPP fn=reinterpret_cast<PFNDRAWMESHARRAYSSUNPROC_HPP>(_impl::_get_proc_address("glDrawMeshArraysSUN","GL_SUN_mesh_array"));
	 fn(mode,first,count,width);
}
#ifndef GL_SUN_slice_accum

#define GL_SUN_slice_accum
#ifndef GL_SLICE_ACCUM_SUN
#define GL_SLICE_ACCUM_SUN                                              0x85CC
#endif //GL_SLICE_ACCUM_SUN

#endif //GL_SUN_slice_accum

#ifndef GL_SUN_triangle_list

#define GL_SUN_triangle_list

#endif //GL_SUN_triangle_list


typedef void (*PFNREPLACEMENTCODEUISUNPROC_HPP)(GLuint code);

static inline void ReplacementCodeuiSUN(GLuint code)
{
	static PFNREPLACEMENTCODEUISUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUISUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEUSSUNPROC_HPP)(GLushort code);

static inline void ReplacementCodeusSUN(GLushort code)
{
	static PFNREPLACEMENTCODEUSSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUSSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeusSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEUBSUNPROC_HPP)(GLubyte code);

static inline void ReplacementCodeubSUN(GLubyte code)
{
	static PFNREPLACEMENTCODEUBSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUBSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeubSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEUIVSUNPROC_HPP)(const GLuint *code);

static inline void ReplacementCodeuivSUN(const GLuint *code)
{
	static PFNREPLACEMENTCODEUIVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUIVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuivSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEUSVSUNPROC_HPP)(const GLushort *code);

static inline void ReplacementCodeusvSUN(const GLushort *code)
{
	static PFNREPLACEMENTCODEUSVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUSVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeusvSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEUBVSUNPROC_HPP)(const GLubyte *code);

static inline void ReplacementCodeubvSUN(const GLubyte *code)
{
	static PFNREPLACEMENTCODEUBVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUBVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeubvSUN","GL_SUN_triangle_list"));
	 fn(code);
}

typedef void (*PFNREPLACEMENTCODEPOINTERSUNPROC_HPP)(GLenum type,GLsizei stride,const GLvoid* *pointer);

static inline void ReplacementCodePointerSUN(GLenum type,GLsizei stride,const GLvoid* *pointer)
{
	static PFNREPLACEMENTCODEPOINTERSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEPOINTERSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodePointerSUN","GL_SUN_triangle_list"));
	 fn(type,stride,pointer);
}
#ifndef GL_SUN_vertex

#define GL_SUN_vertex

#endif //GL_SUN_vertex


typedef void (*PFNCOLOR4UBVERTEX2FSUNPROC_HPP)(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y);

static inline void Color4ubVertex2fSUN(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y)
{
	static PFNCOLOR4UBVERTEX2FSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4UBVERTEX2FSUNPROC_HPP>(_impl::_get_proc_address("glColor4ubVertex2fSUN","GL_SUN_vertex"));
	 fn(r,g,b,a,x,y);
}

typedef void (*PFNCOLOR4UBVERTEX2FVSUNPROC_HPP)(const GLubyte *c,const GLfloat *v);

static inline void Color4ubVertex2fvSUN(const GLubyte *c,const GLfloat *v)
{
	static PFNCOLOR4UBVERTEX2FVSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4UBVERTEX2FVSUNPROC_HPP>(_impl::_get_proc_address("glColor4ubVertex2fvSUN","GL_SUN_vertex"));
	 fn(c,v);
}

typedef void (*PFNCOLOR4UBVERTEX3FSUNPROC_HPP)(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);

static inline void Color4ubVertex3fSUN(GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNCOLOR4UBVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4UBVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glColor4ubVertex3fSUN","GL_SUN_vertex"));
	 fn(r,g,b,a,x,y,z);
}

typedef void (*PFNCOLOR4UBVERTEX3FVSUNPROC_HPP)(const GLubyte *c,const GLfloat *v);

static inline void Color4ubVertex3fvSUN(const GLubyte *c,const GLfloat *v)
{
	static PFNCOLOR4UBVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4UBVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glColor4ubVertex3fvSUN","GL_SUN_vertex"));
	 fn(c,v);
}

typedef void (*PFNCOLOR3FVERTEX3FSUNPROC_HPP)(GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);

static inline void Color3fVertex3fSUN(GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNCOLOR3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glColor3fVertex3fSUN","GL_SUN_vertex"));
	 fn(r,g,b,x,y,z);
}

typedef void (*PFNCOLOR3FVERTEX3FVSUNPROC_HPP)(const GLfloat *c,const GLfloat *v);

static inline void Color3fVertex3fvSUN(const GLfloat *c,const GLfloat *v)
{
	static PFNCOLOR3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glColor3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(c,v);
}

typedef void (*PFNNORMAL3FVERTEX3FSUNPROC_HPP)(GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void Normal3fVertex3fSUN(GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(nx,ny,nz,x,y,z);
}

typedef void (*PFNNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLfloat *n,const GLfloat *v);

static inline void Normal3fVertex3fvSUN(const GLfloat *n,const GLfloat *v)
{
	static PFNNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(n,v);
}

typedef void (*PFNCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP)(GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void Color4fNormal3fVertex3fSUN(GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glColor4fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(r,g,b,a,nx,ny,nz,x,y,z);
}

typedef void (*PFNCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLfloat *c,const GLfloat *n,const GLfloat *v);

static inline void Color4fNormal3fVertex3fvSUN(const GLfloat *c,const GLfloat *n,const GLfloat *v)
{
	static PFNCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glColor4fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(c,n,v);
}

typedef void (*PFNTEXCOORD2FVERTEX3FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z);

static inline void TexCoord2fVertex3fSUN(GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNTEXCOORD2FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fVertex3fSUN","GL_SUN_vertex"));
	 fn(s,t,x,y,z);
}

typedef void (*PFNTEXCOORD2FVERTEX3FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *v);

static inline void TexCoord2fVertex3fvSUN(const GLfloat *tc,const GLfloat *v)
{
	static PFNTEXCOORD2FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fVertex3fvSUN","GL_SUN_vertex"));
	 fn(tc,v);
}

typedef void (*PFNTEXCOORD4FVERTEX4FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void TexCoord4fVertex4fSUN(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNTEXCOORD4FVERTEX4FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4FVERTEX4FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord4fVertex4fSUN","GL_SUN_vertex"));
	 fn(s,t,p,q,x,y,z,w);
}

typedef void (*PFNTEXCOORD4FVERTEX4FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *v);

static inline void TexCoord4fVertex4fvSUN(const GLfloat *tc,const GLfloat *v)
{
	static PFNTEXCOORD4FVERTEX4FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4FVERTEX4FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord4fVertex4fvSUN","GL_SUN_vertex"));
	 fn(tc,v);
}

typedef void (*PFNTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC_HPP)(GLfloat s,GLfloat t,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);

static inline void TexCoord2fColor4ubVertex3fSUN(GLfloat s,GLfloat t,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor4ubVertex3fSUN","GL_SUN_vertex"));
	 fn(s,t,r,g,b,a,x,y,z);
}

typedef void (*PFNTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC_HPP)(const GLfloat *tc,const GLubyte *c,const GLfloat *v);

static inline void TexCoord2fColor4ubVertex3fvSUN(const GLfloat *tc,const GLubyte *c,const GLfloat *v)
{
	static PFNTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor4ubVertex3fvSUN","GL_SUN_vertex"));
	 fn(tc,c,v);
}

typedef void (*PFNTEXCOORD2FCOLOR3FVERTEX3FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);

static inline void TexCoord2fColor3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNTEXCOORD2FCOLOR3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor3fVertex3fSUN","GL_SUN_vertex"));
	 fn(s,t,r,g,b,x,y,z);
}

typedef void (*PFNTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *c,const GLfloat *v);

static inline void TexCoord2fColor3fVertex3fvSUN(const GLfloat *tc,const GLfloat *c,const GLfloat *v)
{
	static PFNTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(tc,c,v);
}

typedef void (*PFNTEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void TexCoord2fNormal3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNTEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(s,t,nx,ny,nz,x,y,z);
}

typedef void (*PFNTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *n,const GLfloat *v);

static inline void TexCoord2fNormal3fVertex3fvSUN(const GLfloat *tc,const GLfloat *n,const GLfloat *v)
{
	static PFNTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(tc,n,v);
}

typedef void (*PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void TexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor4fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(s,t,r,g,b,a,nx,ny,nz,x,y,z);
}

typedef void (*PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v);

static inline void TexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v)
{
	static PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord2fColor4fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(tc,c,n,v);
}

typedef void (*PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC_HPP)(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z,GLfloat w);

static inline void TexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s,GLfloat t,GLfloat p,GLfloat q,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z,GLfloat w)
{
	static PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord4fColor4fNormal3fVertex4fSUN","GL_SUN_vertex"));
	 fn(s,t,p,q,r,g,b,a,nx,ny,nz,x,y,z,w);
}

typedef void (*PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC_HPP)(const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v);

static inline void TexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v)
{
	static PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC_HPP fn=reinterpret_cast<PFNTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC_HPP>(_impl::_get_proc_address("glTexCoord4fColor4fNormal3fVertex4fvSUN","GL_SUN_vertex"));
	 fn(tc,c,n,v);
}

typedef void (*PFNREPLACEMENTCODEUIVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiVertex3fSUN(GLuint rc,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUIVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUIVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUIVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *v);

static inline void ReplacementCodeuiVertex3fvSUN(const GLuint *rc,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUIVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUIVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,v);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC_HPP)(GLuint rc,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc,GLubyte r,GLubyte g,GLubyte b,GLubyte a,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor4ubVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,r,g,b,a,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLubyte *c,const GLfloat *v);

static inline void ReplacementCodeuiColor4ubVertex3fvSUN(const GLuint *rc,const GLubyte *c,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor4ubVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,c,v);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor3fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,r,g,b,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *c,const GLfloat *v);

static inline void ReplacementCodeuiColor3fVertex3fvSUN(const GLuint *rc,const GLfloat *c,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,c,v);
}

typedef void (*PFNREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,nx,ny,nz,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *n,const GLfloat *v);

static inline void ReplacementCodeuiNormal3fVertex3fvSUN(const GLuint *rc,const GLfloat *n,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,n,v);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor4fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,r,g,b,a,nx,ny,nz,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *c,const GLfloat *n,const GLfloat *v);

static inline void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint *rc,const GLfloat *c,const GLfloat *n,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiColor4fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,c,n,v);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,s,t,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *tc,const GLfloat *v);

static inline void ReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint *rc,const GLfloat *tc,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,tc,v);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,s,t,nx,ny,nz,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *tc,const GLfloat *n,const GLfloat *v);

static inline void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint *rc,const GLfloat *tc,const GLfloat *n,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,tc,n,v);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP)(GLuint rc,GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z);

static inline void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc,GLfloat s,GLfloat t,GLfloat r,GLfloat g,GLfloat b,GLfloat a,GLfloat nx,GLfloat ny,GLfloat nz,GLfloat x,GLfloat y,GLfloat z)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN","GL_SUN_vertex"));
	 fn(rc,s,t,r,g,b,a,nx,ny,nz,x,y,z);
}

typedef void (*PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP)(const GLuint *rc,const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v);

static inline void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint *rc,const GLfloat *tc,const GLfloat *c,const GLfloat *n,const GLfloat *v)
{
	static PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP fn=reinterpret_cast<PFNREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC_HPP>(_impl::_get_proc_address("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN","GL_SUN_vertex"));
	 fn(rc,tc,c,n,v);
}
#ifndef GL_SamplePatternSGIS

#define GL_SamplePatternSGIS

#endif //GL_SamplePatternSGIS

#ifndef GL_SeparableTargetEXT

#define GL_SeparableTargetEXT

#endif //GL_SeparableTargetEXT

#ifndef GL_ShadingModel

#define GL_ShadingModel
#ifndef GL_FLAT
#define GL_FLAT                                                         0x1D00
#endif //GL_FLAT
#ifndef GL_SMOOTH
#define GL_SMOOTH                                                       0x1D01
#endif //GL_SMOOTH

#endif //GL_ShadingModel

#ifndef GL_StencilFunction

#define GL_StencilFunction

#endif //GL_StencilFunction

#ifndef GL_StencilOp

#define GL_StencilOp
#ifndef GL_KEEP
#define GL_KEEP                                                         0x1E00
#endif //GL_KEEP
#ifndef GL_INCR
#define GL_INCR                                                         0x1E02
#endif //GL_INCR
#ifndef GL_DECR
#define GL_DECR                                                         0x1E03
#endif //GL_DECR

#endif //GL_StencilOp

#ifndef GL_StringName

#define GL_StringName
#ifndef GL_VENDOR
#define GL_VENDOR                                                       0x1F00
#endif //GL_VENDOR
#ifndef GL_RENDERER
#define GL_RENDERER                                                     0x1F01
#endif //GL_RENDERER
#ifndef GL_VERSION
#define GL_VERSION                                                      0x1F02
#endif //GL_VERSION
#ifndef GL_EXTENSIONS
#define GL_EXTENSIONS                                                   0x1F03
#endif //GL_EXTENSIONS

#endif //GL_StringName

#ifndef GL_TexCoordPointerType

#define GL_TexCoordPointerType

#endif //GL_TexCoordPointerType

#ifndef GL_TextureCoordName

#define GL_TextureCoordName
#ifndef GL_S
#define GL_S                                                            0x2000
#endif //GL_S
#ifndef GL_T
#define GL_T                                                            0x2001
#endif //GL_T
#ifndef GL_R
#define GL_R                                                            0x2002
#endif //GL_R
#ifndef GL_Q
#define GL_Q                                                            0x2003
#endif //GL_Q

#endif //GL_TextureCoordName

#ifndef GL_TextureEnvMode

#define GL_TextureEnvMode
#ifndef GL_DECAL
#define GL_DECAL                                                        0x2101
#endif //GL_DECAL

#endif //GL_TextureEnvMode

#ifndef GL_TextureEnvParameter

#define GL_TextureEnvParameter
#ifndef GL_TEXTURE_ENV_MODE
#define GL_TEXTURE_ENV_MODE                                             0x2200
#endif //GL_TEXTURE_ENV_MODE
#ifndef GL_TEXTURE_ENV_COLOR
#define GL_TEXTURE_ENV_COLOR                                            0x2201
#endif //GL_TEXTURE_ENV_COLOR

#endif //GL_TextureEnvParameter

#ifndef GL_TextureEnvTarget

#define GL_TextureEnvTarget
#ifndef GL_TEXTURE_ENV
#define GL_TEXTURE_ENV                                                  0x2300
#endif //GL_TEXTURE_ENV

#endif //GL_TextureEnvTarget

#ifndef GL_TextureFilterFuncSGIS

#define GL_TextureFilterFuncSGIS

#endif //GL_TextureFilterFuncSGIS

#ifndef GL_TextureGenMode

#define GL_TextureGenMode
#ifndef GL_EYE_LINEAR
#define GL_EYE_LINEAR                                                   0x2400
#endif //GL_EYE_LINEAR
#ifndef GL_OBJECT_LINEAR
#define GL_OBJECT_LINEAR                                                0x2401
#endif //GL_OBJECT_LINEAR
#ifndef GL_SPHERE_MAP
#define GL_SPHERE_MAP                                                   0x2402
#endif //GL_SPHERE_MAP

#endif //GL_TextureGenMode

#ifndef GL_TextureGenParameter

#define GL_TextureGenParameter
#ifndef GL_OBJECT_PLANE
#define GL_OBJECT_PLANE                                                 0x2501
#endif //GL_OBJECT_PLANE
#ifndef GL_EYE_PLANE
#define GL_EYE_PLANE                                                    0x2502
#endif //GL_EYE_PLANE

#endif //GL_TextureGenParameter

#ifndef GL_TextureMagFilter

#define GL_TextureMagFilter
#ifndef GL_NEAREST
#define GL_NEAREST                                                      0x2600
#endif //GL_NEAREST

#endif //GL_TextureMagFilter

#ifndef GL_TextureMinFilter

#define GL_TextureMinFilter
#ifndef GL_NEAREST_MIPMAP_NEAREST
#define GL_NEAREST_MIPMAP_NEAREST                                       0x2700
#endif //GL_NEAREST_MIPMAP_NEAREST
#ifndef GL_LINEAR_MIPMAP_NEAREST
#define GL_LINEAR_MIPMAP_NEAREST                                        0x2701
#endif //GL_LINEAR_MIPMAP_NEAREST
#ifndef GL_NEAREST_MIPMAP_LINEAR
#define GL_NEAREST_MIPMAP_LINEAR                                        0x2702
#endif //GL_NEAREST_MIPMAP_LINEAR
#ifndef GL_LINEAR_MIPMAP_LINEAR
#define GL_LINEAR_MIPMAP_LINEAR                                         0x2703
#endif //GL_LINEAR_MIPMAP_LINEAR

#endif //GL_TextureMinFilter

#ifndef GL_TextureParameterName

#define GL_TextureParameterName

#endif //GL_TextureParameterName

#ifndef GL_TextureTarget

#define GL_TextureTarget
#ifndef GL_PROXY_TEXTURE_1D
#define GL_PROXY_TEXTURE_1D                                             0x8063
#endif //GL_PROXY_TEXTURE_1D
#ifndef GL_PROXY_TEXTURE_2D
#define GL_PROXY_TEXTURE_2D                                             0x8064
#endif //GL_PROXY_TEXTURE_2D

#endif //GL_TextureTarget

#ifndef GL_TextureWrapMode

#define GL_TextureWrapMode
#ifndef GL_CLAMP
#define GL_CLAMP                                                        0x2900
#endif //GL_CLAMP
#ifndef GL_REPEAT
#define GL_REPEAT                                                       0x2901
#endif //GL_REPEAT

#endif //GL_TextureWrapMode

#ifndef GL_VIV_shader_binary

#define GL_VIV_shader_binary
#ifndef GL_SHADER_BINARY_VIV
#define GL_SHADER_BINARY_VIV                                            0x8FC4
#endif //GL_SHADER_BINARY_VIV

#endif //GL_VIV_shader_binary

#ifndef GL_VertexPointerType

#define GL_VertexPointerType

#endif //GL_VertexPointerType


}

#endif